# Job Change Data API - People Movement and Employment Tracking (`nabeelbaghoor/job-change-data-api`) Actor

Search a people dataset for job changes and employment history by company, job function, title and job-change date, and export profiles with current and past roles. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/job-change-data-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Jobs, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00 / 1,000 person 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Job Change Data API - people movement and employment tracking

**Job Change Data API** turns a people-movement dataset into a clean, structured export. Find people by company, job function, title and job-change date, then export profiles with current and past roles - name, title, employer, location, employment status and LinkedIn - as JSON, CSV or Excel.

Bring your own API credentials and pay only for the records you keep.

### Why use this actor?

- **Job-change signals** - find people who recently left or joined a company using a job-change date filter.
- **People search by company** - match everyone with a role at a company by name or LinkedIn slug.
- **Function and title filters** - narrow to a job function such as Engineering or Sales, or a title.
- **Structured output** - name, current title, function, employer, location, employment status, LinkedIn and full job history, parsed into flat columns.
- **Pay per result** - you are charged only for the person records actually returned, up to 2,000 per run.
- **No proxies, no blocks** - data comes through a stable API, so runs are fast and reliable.

### Use cases

- **Job-change alerts** - track when contacts or target buyers change roles and trigger timely outreach.
- **Recruiting and sourcing** - find candidates by current employer, function and title.
- **Champion tracking** - follow former customers and users into their new companies.
- **CRM hygiene** - detect stale contacts whose employment has changed.
- **Talent flow analysis** - map how people move between companies and functions.

### Input

Configure everything from the visual editor - every filter is a proper field, no code needed. Example JSON input:

```json
{
  "companyLinkedin": ["stripe", "spacex"],
  "jobFunction": ["Engineering"],
  "jobEndedFrom": "2026-01-01",
  "matchMode": "and",
  "maxResults": 100,
  "clientId": "YOUR_CLIENT_ID",
  "orgId": "YOUR_ORG_ID",
  "apiKey": "YOUR_CLIENT_SECRET"
}
```

Search by company name and title:

```json
{
  "companyName": "Acme Corp",
  "jobTitle": "product manager",
  "maxResults": 250,
  "clientId": "YOUR_CLIENT_ID",
  "orgId": "YOUR_ORG_ID",
  "apiKey": "YOUR_CLIENT_SECRET"
}
```

### Output

One clean JSON object per person:

```json
{
  "name": "Jane Doe",
  "linkedin": "https://www.linkedin.com/in/janedoe",
  "location": "San Francisco, CA",
  "country": "United States",
  "employmentStatus": "employed",
  "currentTitle": "Staff Engineer",
  "currentFunction": "Engineering",
  "currentCompany": "New Co",
  "lastJobChange": "2026-01-15",
  "jobCount": 4
}
```

### Do I need API credentials?

Yes. This actor calls a people data API on your behalf, which requires your own **Client ID**, **Client secret** and **Organization ID**. They are provisioned by the provider for your organization. The actor exchanges the Client ID and secret for a short-lived access token automatically. Your credentials are stored securely and never logged.

### Pay per result

You pay only for the person records the actor actually returns - no subscriptions, no minimums. Set **Maximum results** to cap each run's spend exactly.

### FAQ

#### What is the Job Change Data API?

It is a people data API that tracks employment history and job changes, letting you search a people dataset by company, job function, title and job-change date. This actor runs that search and exports the matching person records as JSON, CSV or Excel.

#### How do I find recent job changes?

Use the **Left a job on or after** date filter. It matches the job-change date on people's roles, so you can list everyone who left a role after a given date - a strong signal for timely outreach, recruiting or CRM updates.

#### What filters can I use?

Person name, company name, company LinkedIn slug, job function, job title and a job-change date range, combined with AND or OR. For any other supported field, add raw filter leaves in the Advanced field.

#### What data is included per person?

Where available, each record carries name, LinkedIn, location, country, employment status, current title, function and employer, the most recent job-change date and the full job history with companies, titles and dates.

#### How does pagination work?

The actor pages automatically using the API's cursor, up to 2,000 people per run. For larger pulls, split the search by company, function or date range across multiple runs.

#### How much does it cost?

Pricing is pay-per-result: a small fixed amount per person record returned, plus standard Apify platform usage, plus your own API usage against your credentials. A run that returns nothing costs almost nothing.

#### Can I run this on a schedule?

Yes. Use Apify Schedules to run it daily or weekly and connect the dataset to Zapier, Make, n8n, webhooks or the API to push job-change signals into your CRM or outreach tool.

#### Is this legal?

The actor returns professional employment data retrieved through a licensed API using your own credentials. It focuses on business and professional information.

### Keyword map

job change data api, people movement api, employment tracking api, job change alerts api, people data api, contact tracking api, recruiting data api, talent flow api, job change signals api, employment history api, people search api, champion tracking api.

### Support and feedback

Found an issue or missing a filter? Open an issue in the **Issues** tab - it is monitored daily.

# Actor input Schema

## `name` (type: `string`):

Optional fuzzy match on a person's full name, e.g. `Jane Doe`. Combined with the filters below.

## `companyName` (type: `string`):

Match people with a job at this company, by company name, e.g. `Stripe`. Matches the `jobs.company.name` field.

## `companyLinkedin` (type: `array`):

Match people with a job at these companies, by LinkedIn slug, e.g. `stripe`, `spacex` (the part after linkedin.com/company/). Matches `jobs.company.linkedin`. Combined as OR.

## `jobFunction` (type: `array`):

Filter to people whose job function is one of these, e.g. `Engineering`, `Sales`, `Marketing`. Matches `jobs.function`. Combined as OR.

## `jobTitle` (type: `string`):

Fuzzy match on job title, e.g. `product manager`. Matches `jobs.title`.

## `jobEndedFrom` (type: `string`):

Find people who left a role on or after this date (YYYY-MM-DD) - a job-change signal. Matches `jobs.ended_at`.

## `jobEndedTo` (type: `string`):

Upper bound for the job-change date (YYYY-MM-DD). Matches `jobs.ended_at`.

## `matchMode` (type: `string`):

Whether a person must match ALL filters (and) or ANY filter (or).

## `rawFilters` (type: `array`):

Power users: an array of raw filter leaf objects appended to the filters above, each in the form `{ "field": "jobs.company.domain", "type": "must", "match_type": "exact", "string_values": ["stripe.com"] }`. Supports `type` (must/must\_not), `match_type` (exact/fuzzy/exists), `string_values`, `date_from`, `date_to`, `number_min`, `number_max`, `boolean_value`.

## `returnFields` (type: `array`):

Optional list of dot-path fields to return, e.g. `name`, `linkedin`, `jobs.company.name`. Leave empty to return the full person record.

## `sortBy` (type: `string`):

Optional sort, as `+field` for ascending or `-field` for descending, e.g. `-jobs.ended_at`.

## `orgId` (type: `string`):

Your organization ID at the provider, used in the API path. Found in your provider dashboard alongside your service account. Required.

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

Stop after this many people (1-2,000). Paged automatically with a cursor. You are charged per result returned.

## `apiKey` (type: `string`):

Your service account client secret. Required. Used with the Client ID below to obtain a short-lived access token. Stored securely and never logged.

## `clientId` (type: `string`):

Your service account client ID, issued by the provider for your organization. Required.

## Actor input object example

```json
{
  "matchMode": "and",
  "maxResults": 100
}
```

# 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 = {
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/job-change-data-api").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 = { "maxResults": 100 }

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/job-change-data-api").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 '{
  "maxResults": 100
}' |
apify call nabeelbaghoor/job-change-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nabeelbaghoor/job-change-data-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/gWFPm0KVQEwEJBru3/builds/IU9EZw8gPEo6QROzk/openapi.json