# 🔔 Foundit New Jobs Alert Monitor (`hipersoft/foundit-monitor`) Actor

Watch any Foundit (foundit.in) job search on a schedule and get ONLY newly-posted jobs since the last run. Runs in Apify Schedules, n8n, Make or Zapier for automated new-job alerts — quiet runs return nothing, so it is cheap to watch a keyword and location 24/7 and never miss a fresh opening.

- **URL**: https://apify.com/hipersoft/foundit-monitor.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0015 / new job alert

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 🔔 Foundit New Jobs Alert Monitor

**Watch any Foundit (foundit.in) job search and get alerted the moment a new job is posted.** Point this monitor at a job keyword and location — developer, data analyst, digital marketing, sales, anything on Foundit — put it on a schedule, and each run returns **only the jobs newly posted since the last run**. Quiet runs return nothing, so you can watch a search every few minutes, all day, and only ever see fresh openings.

Built for **automation**: drop it into **Apify Schedules**, **n8n**, **Make** or **Zapier** and turn every new job into an email, a Slack message, a Google Sheet row or a webhook.

### Why a monitor instead of a scraper?

A scraper gives you *everything* every time — and you then have to figure out what's new. This monitor remembers what it saw last time and hands you a clean feed of **just the new jobs**:

- 🆕 **New jobs** — the moment a posting matching your search goes live.
- 🗑️ **Removed jobs** — optional. Jobs that were present before but have now been filled, withdrawn or expired.

Perfect for **job seekers who want to apply first**, **recruiters tracking a market**, **job boards aggregating fresh roles**, and anyone building **automated job alerts**.

### How it works

1. Give it a **search** — one or more keywords like `developer` or `data analyst`, and optionally one or more **Locations** like `Mumbai` or `Bengaluru`. You can also paste a Foundit search URL from your browser.
2. Put it on a **schedule** (e.g. every 30 minutes) in Apify or your automation tool.
3. **First run** quietly records the current jobs as a baseline and returns nothing — so a fresh schedule doesn't dump the whole board at you. (Prefer the full list up front? Turn on **Emit all jobs on the first run**.)
4. **Every run after that** returns only the jobs posted since the previous run.

Each monitor keeps its own separate memory, so you can run several different searches side by side without them interfering — just give each one a **Monitor name**.

### What you get

One row per newly-posted job:

| Field | Description |
| --- | --- |
| `changeType` | `new` (newly posted) or `removed` (no longer in results). |
| `jobId` | Foundit job ID. |
| `title` | Job title (e.g. "Scala Developer"). |
| `company` | Hiring company name. |
| `location` | Job location (e.g. "Bengaluru, India"). |
| `experience` | Required experience (e.g. "5-7 Years"). |
| `salary` | Salary when disclosed. |
| `skills` | Key skills for the role. |
| `employmentType` | Full time, contract, etc. |
| `industry` | Industry of the role. |
| `postedDate` | When the job was posted. |
| `url` | Link to the job on Foundit. |
| `applyUrl` | Direct apply link. |
| `firstSeenAt` | When this monitor first saw the job. |
| `lastSeenAt` | When the job was last seen (on removals). |
| `detectedAt` | When this change was detected. |

### Example new-job row

```json
{
  "changeType": "new",
  "jobId": 65621986,
  "title": "Scala Developer",
  "company": "Infosys",
  "location": "Bengaluru, India",
  "experience": "5-7 Years",
  "employmentType": "Full Time, Permanent",
  "url": "https://www.foundit.in/job/scala-developer-infosys-bengaluru-65621986",
  "firstSeenAt": "2026-09-05T12:34:56.000Z",
  "detectedAt": "2026-09-05T12:34:56.000Z"
}
```

### How to use it

1. Add **Foundit New Jobs Alert Monitor** to your Apify account and open its input.
2. Enter one or more **Job keywords** (e.g. `developer`, `data analyst`) and optionally one or more **Locations**.
3. Optionally set a **Monitor name** so this search keeps its own memory.
4. Save it, then create a **Schedule** (e.g. every 30 minutes) — or trigger it from n8n, Make or Zapier.
5. Connect the output to email, Slack, a spreadsheet or a webhook and let the new-job alerts come to you.

### Input

```json
{
  "queries": ["developer", "data analyst"],
  "locations": ["Mumbai", "Bengaluru"],
  "maxItems": 200,
  "monitorName": "dev-jobs-watch",
  "emitBaselineOnFirstRun": false,
  "detectRemoved": false
}
```

| Field | Description |
| --- | --- |
| `queries` | One or more job keywords to watch. Each is monitored as its own search. |
| `locations` | Optional cities to narrow every keyword search. Each keyword is watched in every listed location. |
| `maxItems` | How many jobs from the top of each search to check each run. `0` = no limit. |
| `monitorName` | Optional label so this search keeps its own separate memory. |
| `emitBaselineOnFirstRun` | Output every current job as `new` on the first run instead of seeding silently. |
| `detectRemoved` | Also report removed jobs (default off). |

### FAQ

**How often should I run it?**
As often as you like — every 15 or 30 minutes works well. Runs with no new jobs return nothing, so frequent checks stay cheap.

**Will the first run flood me with results?**
No. By default the first run silently records a baseline and returns nothing; you only start getting rows from the second run onward. Turn on **Emit all jobs on the first run** if you'd rather get the full list up front.

**Can I watch several searches at once?**
Yes. Give each one a different **Monitor name** and each keeps its own independent memory of what it has seen.

**Can I watch multiple cities?**
Yes — add several **Locations** and every keyword is watched in each of them.

**What export and integration options are there?**
JSON, CSV, Excel and XML, plus the Apify API, webhooks and native integrations with n8n, Make, Zapier and more.

# Actor input Schema

## `queries` (type: `array`):

One or more job keywords to monitor on Foundit — for example 'developer', 'data analyst' or 'digital marketing'. Each keyword is watched as its own saved search and each run reports only the jobs that were newly posted since the previous run. You can also paste a Foundit search URL straight from your browser.

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

Optional. One or more cities to narrow every keyword search — for example 'Mumbai', 'Bengaluru' or 'Delhi'. Each keyword is watched in every listed location. Leave empty to watch across all locations.

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

How many jobs from the top of each search to check every run (0 = no limit). The newest jobs appear first, so 200 comfortably covers fresh arrivals for most searches. Removed-job detection is only reported when this cap is not reached.

## `monitorName` (type: `string`):

Optional label for this monitor. Each named monitor keeps its own separate memory of the jobs it has already seen, so you can run several different searches side by side without them interfering. Leave blank to derive it automatically from the search.

## `emitBaselineOnFirstRun` (type: `boolean`):

By default the very first run silently records the current jobs as a baseline and returns nothing, so a fresh schedule does not dump the whole job board at you. Turn this on to instead output every current job as 'new' on that first run.

## `detectRemoved` (type: `boolean`):

Also report jobs that were present before but have now disappeared from the search (filled, withdrawn or expired). Only reported when the whole search fits within 'Max jobs to check per run'.

## `proxyConfiguration` (type: `object`):

Optional. This monitor runs fine without a proxy and none is used by default.

## Actor input object example

```json
{
  "queries": [
    "developer"
  ],
  "maxItems": 200,
  "emitBaselineOnFirstRun": false,
  "detectRemoved": false
}
```

# Actor output Schema

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

The detected new (and removed) jobs as dataset items.

# 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 = {
    "queries": [
        "developer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/foundit-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 = { "queries": ["developer"] }

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/foundit-monitor").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 '{
  "queries": [
    "developer"
  ]
}' |
apify call hipersoft/foundit-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hipersoft/foundit-monitor"
        }
    }
}
```

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/nLt6ojm5XYxw5YtpQ/builds/onkdmbTd4jYunT8VV/openapi.json