# Company Careers Job Monitor (`techionik9993/company-careers-job-monitor`) Actor

Find and monitor jobs from company careers pages and ATS boards like Greenhouse, Lever, Ashby, and SmartRecruiters. Uses no proxy by default, respects strict job limits, and stores monitoring state without creating duplicate paid result rows.

- **URL**: https://apify.com/techionik9993/company-careers-job-monitor.md
- **Developed by:** [Techionik](https://apify.com/techionik9993) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.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

## Company Careers Job Monitor

Find jobs from company careers pages and optionally monitor companies for new, removed, or changed roles.

This Actor is built for a profit-safe, predictable billing model. It uses simple HTTP requests, does not use a browser, and does not use proxies unless you enable them.

### What You Get

- Job title
- Company domain
- Job URL
- Location when detected
- Department/team when detected
- Source system, such as Greenhouse, Lever, Ashby, SmartRecruiters, JSON-LD, or the careers page
- Optional monitoring changes between runs

### Quick Start

1. Enter company domains or careers-page URLs, for example `companycam.com` or `https://boards.greenhouse.io/embed/job_board?for=companycam`.
2. Set **Max jobs per company** to the number of job rows you want.
3. Leave **Proxy mode** set to **No proxy** for the lowest platform cost.
4. Add job title or location filters only if you want a narrower dataset.
5. Turn on **Monitor changes since last run** when running the Actor on a schedule.

### Result Limits And Billing

Apify pay-per-event result billing is based on rows written to the default dataset. This Actor keeps that simple:

- If **Max jobs per company** is `100`, normal output writes up to 100 job rows per company.
- Monitoring snapshots and latest change details are stored in a named key-value store so scheduled runs can compare against previous runs.
- Monitoring does not double the normal dataset output.
- Change rows are written to the dataset only when **Output only the changes** is enabled.
- Empty or blocked companies are logged in the run status instead of written as paid result rows.

If you provide 5 companies and set **Max jobs per company** to `100`, the maximum normal output is 500 job rows.

### Proxy Strategy

Proxy use affects platform cost, so the default is intentionally conservative:

- **No proxy:** best margin, recommended first choice.
- **Auto fallback to datacenter:** tries without proxy first, then retries blocked requests with Apify datacenter proxy.
- **Datacenter proxy:** useful for moderate blocking.
- **Residential proxy:** strongest but most expensive; use only when the target company blocks other methods.

For most company careers pages, start with **No proxy** or **Auto fallback to datacenter**.

### Monitoring Logic

When monitoring is enabled, the Actor:

1. Fetches current jobs for each company.
2. Applies filters and the selected job limit.
3. Compares the current jobs with the previous snapshot for that company.
4. Saves the new snapshot to a named key-value store.
5. Saves latest detected changes to a key such as `changes-example.com`.
6. Outputs either job rows or change rows, depending on **Output only the changes**.

Detected change types:

- `new_job`
- `removed_job`
- `changed_job`

### Input Options

#### Company Websites Or Careers URLs

Company domains, websites, or direct career-page URLs.

#### Job Title Keywords

Optional filters matched against title, department, location, description, and URL.

#### Location Keywords

Optional filters for locations such as `remote`, `london`, or `new york`.

#### Max Jobs Per Company

Maximum job rows to write per company in normal output mode. Use `0` to output all detected jobs.

#### Monitor Changes Since Last Run

Compares the current run with the previous saved snapshot for each company.

#### Output Only The Changes

Outputs change events instead of job rows. Use this for scheduled monitoring when you only want newly detected changes.

#### Proxy Mode

Controls whether Apify Proxy is used. Residential proxy can increase platform usage cost and should be reserved for blocked targets.

### Storage

The Actor uses the named key-value store `company-careers-job-monitor-state` for monitoring state:

- `snapshot-<company>` stores the latest job snapshot.
- `changes-<company>` stores the latest detected changes.

### Notes

- Careers systems such as Greenhouse, Lever, Ashby, and SmartRecruiters are supported directly when detected.
- Some company sites render jobs only in protected browser-only applications. Those may need a separate browser-based premium Actor.
- For best profit margin, keep proxy mode conservative and charge only for useful job rows.

# Actor input Schema

## `companyUrls` (type: `array`):

Company domains, websites, or direct careers-page URLs. Examples: companycam.com, https://boards.greenhouse.io/embed/job_board?for=companycam
## `keywords` (type: `array`):

Optional keywords to match in job titles, departments, or descriptions. Leave empty to return all detected jobs.
## `locations` (type: `array`):

Optional location filters. Examples: remote, london, new york, united states.
## `maxJobsPerCompany` (type: `integer`):

Maximum job rows to write per company in normal output mode. 0 = all detected jobs.
## `monitorChanges` (type: `boolean`):

Compare against the previous saved snapshot in a named key-value store and store new, removed, and changed jobs there. Normal job output still respects Max jobs per company.
## `onlyChanges` (type: `boolean`):

When monitoring is on, output change events instead of job rows. Leave off for normal job output.
## `proxyMode` (type: `string`):

Use no proxy by default for best profit margin. Auto retries blocked requests with Apify datacenter proxy. Residential should be used only when necessary because it increases platform usage cost.
## `proxyCountryCode` (type: `string`):

Optional two-letter country code for residential proxy, for example US or GB. Used only when Proxy mode is Residential.
## `includeDescriptions` (type: `boolean`):

Include short job description text when detected. Keeping this off produces smaller, cheaper result rows.

## Actor input object example

```json
{
  "companyUrls": [
    "companycam.com",
    "https://boards.greenhouse.io/embed/job_board?for=companycam"
  ],
  "keywords": [
    "sales",
    "engineer",
    "customer success"
  ],
  "locations": [
    "remote",
    "london"
  ],
  "maxJobsPerCompany": 100,
  "monitorChanges": false,
  "onlyChanges": false,
  "proxyMode": "none",
  "proxyCountryCode": "",
  "includeDescriptions": false
}
````

# Actor output Schema

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

Normal runs contain job rows. When Output only the changes is enabled, rows contain change events.

# 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 = {
    "companyUrls": [
        "https://boards.greenhouse.io/embed/job_board?for=companycam"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("techionik9993/company-careers-job-monitor").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 = { "companyUrls": ["https://boards.greenhouse.io/embed/job_board?for=companycam"] }

# Run the Actor and wait for it to finish
run = client.actor("techionik9993/company-careers-job-monitor").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 '{
  "companyUrls": [
    "https://boards.greenhouse.io/embed/job_board?for=companycam"
  ]
}' |
apify call techionik9993/company-careers-job-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=techionik9993/company-careers-job-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Company Careers Job Monitor",
        "description": "Find and monitor jobs from company careers pages and ATS boards like Greenhouse, Lever, Ashby, and SmartRecruiters. Uses no proxy by default, respects strict job limits, and stores monitoring state without creating duplicate paid result rows.",
        "version": "0.0",
        "x-build-id": "Deqhbp2ZW5myAPqaa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/techionik9993~company-careers-job-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-techionik9993-company-careers-job-monitor",
                "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/techionik9993~company-careers-job-monitor/runs": {
            "post": {
                "operationId": "runs-sync-techionik9993-company-careers-job-monitor",
                "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/techionik9993~company-careers-job-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-techionik9993-company-careers-job-monitor",
                "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",
                "required": [
                    "companyUrls"
                ],
                "properties": {
                    "companyUrls": {
                        "title": "Company websites or careers URLs",
                        "type": "array",
                        "description": "Company domains, websites, or direct careers-page URLs. Examples: companycam.com, https://boards.greenhouse.io/embed/job_board?for=companycam",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Job title keywords",
                        "type": "array",
                        "description": "Optional keywords to match in job titles, departments, or descriptions. Leave empty to return all detected jobs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Location keywords",
                        "type": "array",
                        "description": "Optional location filters. Examples: remote, london, new york, united states.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxJobsPerCompany": {
                        "title": "Max jobs per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum job rows to write per company in normal output mode. 0 = all detected jobs.",
                        "default": 100
                    },
                    "monitorChanges": {
                        "title": "Monitor changes since last run",
                        "type": "boolean",
                        "description": "Compare against the previous saved snapshot in a named key-value store and store new, removed, and changed jobs there. Normal job output still respects Max jobs per company.",
                        "default": false
                    },
                    "onlyChanges": {
                        "title": "Output only the changes",
                        "type": "boolean",
                        "description": "When monitoring is on, output change events instead of job rows. Leave off for normal job output.",
                        "default": false
                    },
                    "proxyMode": {
                        "title": "Proxy mode",
                        "enum": [
                            "none",
                            "auto",
                            "datacenter",
                            "residential"
                        ],
                        "type": "string",
                        "description": "Use no proxy by default for best profit margin. Auto retries blocked requests with Apify datacenter proxy. Residential should be used only when necessary because it increases platform usage cost.",
                        "default": "none"
                    },
                    "proxyCountryCode": {
                        "title": "Residential proxy country",
                        "type": "string",
                        "description": "Optional two-letter country code for residential proxy, for example US or GB. Used only when Proxy mode is Residential.",
                        "default": ""
                    },
                    "includeDescriptions": {
                        "title": "Include descriptions",
                        "type": "boolean",
                        "description": "Include short job description text when detected. Keeping this off produces smaller, cheaper result rows.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```