# Jobvite Jobs Scraper - ATS Hiring Data (`benthepythondev/jobvite-jobs-scraper`) Actor

Scrape public Jobvite career pages for job titles, locations, job IDs and direct application URLs.

- **URL**: https://apify.com/benthepythondev/jobvite-jobs-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Jobvite Jobs Scraper - ATS Hiring Data

Scrape public Jobvite career pages and turn their job tables into clean hiring datasets. The actor accepts Jobvite company slugs or full search URLs, reads the server-rendered job list, and returns job title, location, job ID, direct Jobvite URL, source domain, and multi-location flags. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### What is the Jobvite Jobs Scraper?

Jobvite is a widely used applicant tracking system for companies that publish jobs on `jobs.jobvite.com`. Recruiters, lead-gen teams, labor-market researchers, enrichment vendors, and sales teams often need a simple way to monitor which companies are hiring, where roles are located, and which job pages are newly visible. This actor turns public Jobvite search pages into structured rows without requiring a browser, login, cookie, or paid API.

The actor is intentionally focused on the public job listing table. That makes it fast and reliable for daily Apify auto-tests and scheduled monitoring. It is useful as a lightweight source of hiring intent: a company adding new roles, opening a new location, or expanding a function can be a sales signal for recruiters, agencies, SaaS vendors, consultants, real-estate teams, relocation providers, and B2B lead-gen workflows.

#### What data does it extract?

- Search label or input company
- Jobvite company slug
- Job title
- Job location text
- Multi-location flag
- Direct Jobvite job URL
- Job ID from the URL
- Source name
- Source domain
- Final search URL after redirects

### Input

| Field | Type | Description |
| --- | --- | --- |
| `companies` | array | Jobvite company slugs, such as `nutanix`. |
| `searchUrls` | array | Full Jobvite search URLs to scrape exactly. |
| `keyword` | string | Optional keyword appended to company slug searches. |
| `maxResults` | integer | Maximum jobs returned per company or search URL. |

#### Example input

```json
{
  "companies": ["nutanix"],
  "keyword": "engineer",
  "maxResults": 25
}
````

You can also paste a full search URL:

```json
{
  "searchUrls": ["https://jobs.jobvite.com/nutanix/search?q=sales"],
  "maxResults": 50
}
```

### Output

```json
{
  "search": "nutanix",
  "company_slug": "nutanix",
  "title": "Backend/ Software Engineer",
  "location": "Vancouver, British Columbia",
  "is_multi_location": false,
  "url": "https://jobs.jobvite.com/nutanix/job/oTNeAfwe",
  "job_id": "oTNeAfwe",
  "source": "jobvite",
  "domain": "jobs.jobvite.com",
  "final_url": "https://jobs.jobvite.com/nutanix/search"
}
```

### Use cases

- Hiring intelligence: monitor target accounts and identify companies actively expanding.
- Recruiting lead generation: find new roles by company, location, or keyword.
- Sales triggers: detect open roles that imply budget, tooling needs, or team growth.
- Market research: export hiring data across a list of Jobvite-backed companies.

### Practical tips

Use company slugs when you know the Jobvite tenant name. The slug is the part after `jobs.jobvite.com/`, for example `nutanix` in `https://jobs.jobvite.com/nutanix/search`. Use full search URLs when you have already applied Jobvite's own filters or search query in the browser.

For account-based sales, keep a list of target company slugs and run the actor every day or week. Compare output by `job_id` to find newly posted roles. For recruiting workflows, combine this actor with company enrichment and contact-finding actors so hiring intent becomes a practical prospecting list.

### Reliability and performance

The actor uses direct HTTP requests against public Jobvite career pages and parses the server-rendered HTML table. It does not use a browser, which keeps runtime and cost low. If one company URL fails, the actor logs the issue and continues with the remaining targets. The default run is intentionally small and non-empty so Apify's daily health checks remain stable.

### Data quality notes

Jobvite tenants can customize their career pages. The standard search page exposes the most reliable shared fields: title, location, and detail URL. Some companies put extra data on detail pages, while others keep detail pages minimal, so this actor favors the consistent search result fields that work across many tenants. For most monitoring and lead-gen workflows, those fields are enough to detect hiring intent, deduplicate jobs by ID, and send users to the original posting for application details.

If a company shows "2 Locations" or "5 Locations" in the listing table, the actor marks `is_multi_location` as true. That gives downstream workflows a useful signal without pretending to know every location before opening the detail page.

### FAQ

**Does it require a Jobvite account?** No. It reads public career pages.

**Can it scrape any Jobvite company?** It works on public Jobvite career pages that use the standard `jobs.jobvite.com/<company>/search` layout.

**Does it open each job detail page?** This version extracts the listing table and direct job URL. Detail-page enrichment can be added for custom use cases.

**Can I search by keyword?** Yes. Provide `keyword` for company slug searches, or paste a filtered Jobvite search URL.

**Can I export the results?** Yes. Apify datasets export to JSON, CSV, Excel, XML, and RSS.

**Can I schedule it?** Yes. Create an Apify task and schedule it to monitor hiring changes.

**Is it legal?** The actor reads public job postings. You are responsible for respecting website terms, rate limits, and applicable laws.

**How is billing calculated?** Pay-per-event billing charges per job row pushed to the dataset.

**What if a company uses a custom careers domain?** If it still renders through Jobvite and exposes a Jobvite search URL, paste that URL directly.

**Does it include salaries?** The public Jobvite table usually does not include salary. The actor returns the reliable fields visible in the search results.

### You might also like

- Greenhouse Jobs Scraper
- Lever Jobs Scraper
- Workday Jobs Scraper
- BambooHR Jobs Scraper
- HiringCafe Scraper

**Keywords:** Jobvite scraper, Jobvite jobs scraper, ATS scraper, job board scraper, hiring data, recruiting leads, job postings API, company hiring monitor, B2B lead generation, talent intelligence, jobs dataset, Apify jobs scraper, applicant tracking system scraper, job search automation, public job listings

# Actor input Schema

## `companies` (type: `array`):

Jobvite company slugs such as nutanix, or full Jobvite search URLs.

## `searchUrls` (type: `array`):

Full Jobvite search URLs to scrape exactly. These are used in addition to company slugs.

## `keyword` (type: `string`):

Optional search keyword for company slug searches.

## `maxResults` (type: `integer`):

Maximum number of jobs to return per company or URL.

## Actor input object example

```json
{
  "companies": [
    "nutanix"
  ],
  "searchUrls": [
    "https://jobs.jobvite.com/nutanix/search"
  ],
  "maxResults": 10
}
```

# 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 = {
    "companies": [
        "nutanix"
    ],
    "searchUrls": [
        "https://jobs.jobvite.com/nutanix/search"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/jobvite-jobs-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 = {
    "companies": ["nutanix"],
    "searchUrls": ["https://jobs.jobvite.com/nutanix/search"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/jobvite-jobs-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "companies": [
    "nutanix"
  ],
  "searchUrls": [
    "https://jobs.jobvite.com/nutanix/search"
  ],
  "maxResults": 10
}' |
apify call benthepythondev/jobvite-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=benthepythondev/jobvite-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobvite Jobs Scraper - ATS Hiring Data",
        "description": "Scrape public Jobvite career pages for job titles, locations, job IDs and direct application URLs.",
        "version": "1.0",
        "x-build-id": "24iaUuRGjlTIqdUaI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~jobvite-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-jobvite-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/benthepythondev~jobvite-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-jobvite-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/benthepythondev~jobvite-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-jobvite-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "companies": {
                        "title": "Jobvite company slugs",
                        "type": "array",
                        "description": "Jobvite company slugs such as nutanix, or full Jobvite search URLs.",
                        "default": [
                            "nutanix"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Full Jobvite search URLs to scrape exactly. These are used in addition to company slugs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional search keyword for company slug searches."
                    },
                    "maxResults": {
                        "title": "Max results per target",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of jobs to return per company or URL.",
                        "default": 25
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
