# Global Job Postings — live ATS index (`nivult/global-job-postings`) Actor

Live job postings and enriched employer records, read directly from the career systems of tens of thousands of companies. Filter by country, technology, seniority, workplace. Every field carries its source.

- **URL**: https://apify.com/nivult/global-job-postings.md
- **Developed by:** [Nivult](https://apify.com/nivult) (community)
- **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/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

![Nivult — live job postings, read at the source](https://raw.githubusercontent.com/granno-dev/nivult-engine/main/apify/assets/copertina.png)

### Not another scraper. A maintained index.

Most job actors ask you for career-site URLs, then spend minutes scraping them, then hand you raw rows. **This Actor asks for nothing but filters** — and answers in seconds, because the work is already done: we read the career systems of tens of thousands of employers **every day**, whether you run us or not.

| | Scrape-on-demand actors | **Nivult Dataset API** |
|---|---|---|
| You supply | career-site URLs you must know | nothing — just filters |
| Answer in | minutes of scraping | **seconds** |
| Closed postings | stay in your data forever | **verified closed**, daily |
| Enrichment | raw title + link | seniority, workplace, language, skills, salary signal |
| Company layer | a name string | **spine record: industry, size, legal identity, tech stack** |
| Provenance | none | **field-level, on every row** |

### What does the Nivult Job Index do?

We read job postings **directly from the career systems of tens of thousands of employers** — Workday, Greenhouse, Lever, SmartRecruiters, SuccessFactors and dozens more — across 240+ countries and territories. Refreshed daily; closed when the posting leaves the employer's own page.

Filter by what matters:

- 🌍 **Country** — 240+ countries and territories, ISO-2
- 🧩 **Technology** — postings that mention SAP, Snowflake, Kubernetes… in the text
- 🎯 **Seniority & workplace** — intern to head, remote / hybrid / on site
- 🗓️ **Posted-after date** — only what is fresh
- 🏢 **Company mode** — industry, size band, legal identity from public registries, measured technology stack

![How it works: you set filters, the index refreshes daily, you get clean rows in seconds](https://raw.githubusercontent.com/granno-dev/nivult-engine/main/apify/assets/diagramma-v2.png)

### How to use it

1. Choose **Job postings** or **Companies**.
2. Set your filters — country, technology, keyword, seniority, workplace, posted-after.
3. Run, and download the dataset as JSON, CSV, or Excel — or read it through the Apify API.

Every result set is a slice of the same index we sell as a full daily feed.

### How much does it cost — and why is a row worth more here?

**$3 per 1,000 rows received** — nothing for empty filters, nothing upfront. On Apify's free plan, your monthly free usage covers your first hundreds of rows.

A fair question: raw-scrape actors charge cents per thousand. A raw row is a title and a link that may be dead by tonight. Our row is an **enriched, verified record**: classified seniority and workplace, measured skills and language, salary signal, a link to the company's spine record, and the source of every field — closed out of the index the day it leaves the source. You are not paying for a scrape; you are paying for the maintenance.

For the full daily export or a custom feed (millions of rows, JSONL, daily deltas), write to us — the Actor page links to the contact.

### What does the output look like?

A real row from the index, verbatim (the posting went live the same day):

```json
{
  "title": "Logistics Deduction Management Analyst",
  "company": "Hisenseusacorporation",
  "ats": "bamboohr",
  "country": "US",
  "city": "Alpharetta",
  "remote": "onsite",
  "seniority": "junior",
  "technologies": ["Excel", "Microsoft Office", "PowerPoint", "SAP", "Word"],
  "salary_estimate_median": 41600,
  "salary_estimate_currency": "USD",
  "salary_is_estimate": true,
  "posted_at": "2026-10-06",
  "url": "https://hisenseusacorporation.bamboohr.com/careers/349"
}
```

And **company mode** is a different league — one record per employer, with every enrichment carrying its own source:

```json
{
  "company": "Italgas",
  "domain": "italgas.it",
  "active_jobs": 92,
  "industry": "Distribution of gaseous fuels",
  "industry_source": "wikidata",
  "legal_name": "ITALGAS S.P.A.",
  "legal_form": "Società Per Azioni",
  "registration_id": "815600F25FF44EF1FA76",
  "founded": "2016-05-31",
  "size_range": "1001-5000",
  "size_range_source": "pdl (free dataset)"
}
```

Company mode returns one record per employer: name, domain, industry, size band, legal form from public registries, technology stack, and the count of live postings.

### Explore the Nivult family

- **[Job Postings Dataset — the full index](https://apify.com/nivult/global-job-postings)** — every ATS, every filter, company mode
- **[Workday Jobs Dataset](https://apify.com/nivult/workday-jobs-dataset)** — every Workday career site, daily
- **[Greenhouse Jobs Dataset](https://apify.com/nivult/greenhouse-jobs-dataset)** — every Greenhouse board, daily
- **[Jobs by Technology](https://apify.com/nivult/jobs-by-technology)** — postings matched by the stack in the text

### FAQ

**Where does the data come from?**
From the employers' own career systems — the page where the company itself publishes the opening. A closure is verified: the posting left the source.

**How fresh is it?**
The index refreshes every day; new postings land within 24 hours of appearing at the source.

**Is this legal?**
We read public pages that employers publish for candidates, respect robots directives and rate limits, and honor removal requests. The company records enrich public postings with public registries.

**Can I get the data through an API instead of the UI?**
Yes — the dataset of every run is readable through the Apify API, and the full index has its own REST API with daily JSONL exports. Ask us through the store page.

**Something looks off — who do I tell?**
Write to us from the store page. We read everything, and we fix fast.

# Actor input Schema

## `tipo` (type: `string`):

Job postings or enriched company records

## `country` (type: `string`):

e.g. IT, DE, US — leave empty for worldwide

## `technology` (type: `string`):

e.g. SAP, Snowflake, Kubernetes — postings mentioning it in the text

## `q` (type: `string`):

free text in title and description

## `seniority` (type: `string`):

Filter by seniority level (optional)

## `remote` (type: `string`):

Filter by workplace type (optional)

## `dal` (type: `string`):

ISO date, e.g. 2026-10-01 — only fresher postings

## `limite` (type: `integer`):

1–10,000 (for bigger slices ask about the daily full export)

## Actor input object example

```json
{
  "tipo": "jobs",
  "seniority": "",
  "remote": "",
  "limite": 100
}
```

# Actor output Schema

## `results` (type: `string`):

The records matching your filters, in the default dataset — view them as a table or download as JSON, CSV, Excel.

# 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("nivult/global-job-postings").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("nivult/global-job-postings").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 nivult/global-job-postings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nivult/global-job-postings"
        }
    }
}
```

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/cFKfjFUwiBkApi4CJ/builds/FoCStT0oFzO2s3Vm8/openapi.json