# Indeed Alternative — Public Company Job Monitor (`khadinakbar/indeed-alternative`) Actor

Collect current public job postings from selected Greenhouse, Lever, and Ashby employer boards. Use for a targeted company watchlist, not a global Indeed index or job applications.

- **URL**: https://apify.com/khadinakbar/indeed-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 validated public job returneds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## Indeed Alternative: Public Company Job Monitor

Collect current job postings from a company watchlist that uses a public Greenhouse, Lever, or Ashby board. Give the Actor a supported source and board slug for each target company; it returns normalized job records with public URLs, source-endpoint provenance, and a collection timestamp.

Use it for recruiter target-account monitoring, job-market research, or an agent that already knows the employers to check. The workflow focuses on read-only collection from documented public job-listing endpoints; global discovery, applications, candidate data, resume matching, and employer hiring workflows belong with the relevant marketplace or ATS product.

### Output: public job records

One dataset row per validated public posting:

| Field | Meaning |
| --- | --- |
| `source` and `boardSlug` | The public ATS source and caller-supplied employer board identifier. |
| `jobId`, `title`, `location`, `department` | Stable source job identity and the public fields available from that board. |
| `applyUrl` and `jobUrl` | Public links supplied by the job board. |
| `descriptionText` | Clean public description text when `includeDescriptions` is enabled. |
| `compensation` | A public salary component only when the source exposes it. |
| `sourceApiUrl` and `collectedAt` | Provenance endpoint and the time this record was read. |

Missing source data stays `null`; the Actor does not infer salary, work authorization, company identity, or whether a job remains open after this run.

### Input

```json
{
  "boards": [
    { "source": "greenhouse", "slug": "stripe" },
    { "source": "ashby", "slug": "ashby" }
  ],
  "maxResults": 50,
  "titleIncludes": "engineer",
  "locationIncludes": "remote",
  "includeDescriptions": true
}
```

Supported board slugs are the final identifier in the public board URL: `job-boards.greenhouse.io/<slug>`, `jobs.lever.co/<slug>`, or `jobs.ashbyhq.com/<slug>`. The Actor intentionally requires those identifiers—it does not guess a company board from a brand name or crawl an employer homepage.

Example record shape:

```json
{
  "source": "greenhouse",
  "boardSlug": "stripe",
  "jobId": "42",
  "companyName": "stripe",
  "title": "Platform Engineer",
  "location": "Remote — US",
  "department": "Engineering",
  "applyUrl": "https://boards.greenhouse.io/stripe/jobs/42",
  "jobUrl": "https://boards.greenhouse.io/stripe/jobs/42",
  "sourceApiUrl": "https://boards-api.greenhouse.io/v1/boards/stripe/jobs?content=true",
  "collectedAt": "2026-08-31T12:00:00.000Z"
}
```

### Pricing and cost guidance

The intended **Pay per event** price is **$0.005 per validated job posting**, plus a **$0.00005** Actor-start event. Apify platform usage is additional. `maxResults` is a hard output and event-charge guard; the Actor displays the maximum event-charge amount before it retrieves a board and records actual event counts in `OUTPUT` and `RUN_SUMMARY`. After deployment, the live Actor **Pricing tab** is the current source of truth for the effective event and platform-usage contract.

Before the first private deployment, configured prices are planning values. A same-job benchmark is the right next step for any relative-cost decision against Indeed or another service.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow for a defined employer watchlist. Start with the companies you actively track, add their public ATS source and slug, then use the returned public URLs to review the openings or feed a separate approved analysis workflow.

### How this bounded workflow compares with Indeed

This is an independent, focused alternative for one job: collecting a known employer watchlist from supported public ATS boards. Indeed is the stronger route for marketplace-wide job discovery, job alerts, applications, candidate matching, employer dashboard, sponsored listings, and other hiring-suite features.

| Decision | This Actor | Indeed | Best fit |
| --- | --- | --- | --- |
| Starting point | Known public Greenhouse, Lever, or Ashby board slugs | Marketplace search and account experience | Use this Actor when your employer watchlist is already defined. |
| Effective efficiency | One normalized, source-labeled job record per accepted listing | No current equivalent export/API test was performed | Use the Actor when API/dataset-ready records and endpoint provenance matter. |
| Scope | Read-only public job-board collection | Broad job marketplace and employer suite | Use Indeed for discovery, alerts, applications, or hiring workflow. |
| Billing | Intended per-validated-record event price plus platform usage | Dynamic sponsored-job pricing; not the same job | Compare costs only for the same fields, volume, and workflow. |
| Freshness | Reads supported public endpoints during the run and records `collectedAt` | Equivalent export provenance was not assessed | Re-run the watchlist when you need a fresh observation. |
| Automation | Batch input and terminal artifacts are implemented locally | Not compared | Cloud scheduling/API/MCP claims wait for live tests. |

Indeed is a trademark of its owner. This independent Actor is not affiliated, associated, or endorsed by Indeed.

### API

After private deployment, start a run through the Apify API and read the resulting dataset:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/indeed-alternative').call({
  boards: [{ source: 'greenhouse', slug: 'stripe' }],
  maxResults: 10,
  includeDescriptions: false
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Agent prompt card

> As an AI agent, collect open engineering roles from these known public employer boards. Use the supplied Greenhouse, Lever, and Ashby slugs, then read back the dataset. Return title, location, public apply URL, source endpoint, collection time, terminal outcome, and the event-cost boundary. Keep the request within this focused watchlist scope.

### Best results and source guidance

- Provide the exact public source and board slug for every employer. The public endpoint is read at run time, then the normalized result appears in the dataset.
- Start with a small `maxResults` value to confirm the board and filters, then schedule the same saved input when a recurring snapshot supports your workflow.
- Use `titleIncludes` and `locationIncludes` for literal, case-insensitive narrowing. Verify the returned public application URL before acting on a listing.
- Read `OUTPUT` for the compact terminal outcome and `RUN_SUMMARY` for source coverage, record counts, event charges, and guidance for the next targeted input.

Public job boards expose different fields. The normalized contract preserves available values, explicit nulls, source provenance, and the collection time so the next workflow step can make a current, informed decision.

### Builder's note

I designed this around the public APIs that career sites use to render their own listings: Greenhouse, Lever, and Ashby. I found that a caller-supplied employer watchlist makes the data boundary and freshness clearer than a fragile global-board scrape, while keeping every record tied to its public source URL.

### Responsible use

Use only public employer boards you are authorized to monitor. Respect source terms, rate limits, privacy law, and job candidates' rights. The Actor is read-only and keeps application submission, applicant information, private portals, and hiring decisions with the appropriate authorized system.

# Actor input Schema

## `boards` (type: `array`):

Provide up to 25 public employer boards as source-and-slug objects, for example {"source":"greenhouse","slug":"openai"}. Supported sources are greenhouse, lever, and ashby; the slug is the final path component of that source's public job board URL. This is required and is not an Indeed URL, a company homepage, a login, or an application URL.

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

Caps the total validated job postings written during this run, for example 100. It defaults to 100 and accepts values from 1 through 500. This is a run-wide output and billable-event limit, not a number of boards or a promise that every board has that many jobs.

## `titleIncludes` (type: `string`):

Optionally retain public postings whose title contains literal text such as engineer. Matching is case-insensitive and happens before a matching record is written or billed. Leave it blank to keep all titles; this is not Boolean search or a full-text description query.

## `locationIncludes` (type: `string`):

Optionally retain public postings whose supplied location contains literal text such as remote or london. Matching is case-insensitive and uses the source board's own location text. Leave it blank to keep every location; this does not geocode roles or infer work authorization.

## `includeDescriptions` (type: `boolean`):

Controls whether records contain the public listing description in original HTML and clean text. It defaults to true for research and agent workflows; set false for smaller result records. This never retrieves candidate information, hiring notes, or application answers.

## Actor input object example

```json
{
  "boards": [
    {
      "source": "greenhouse",
      "slug": "stripe"
    },
    {
      "source": "lever",
      "slug": "lever"
    }
  ],
  "maxResults": 100,
  "titleIncludes": "engineer",
  "locationIncludes": "remote",
  "includeDescriptions": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

Normalized public job records returned by the requested employer-board watchlist.

## `output` (type: `string`):

Compact outcome, item counts, warning summary, and charged event totals.

## `runSummary` (type: `string`):

Detailed public-board coverage, diagnostics, and billing information.

# 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 = {
    "boards": [
        {
            "source": "greenhouse",
            "slug": "stripe"
        }
    ],
    "maxResults": 100,
    "titleIncludes": "",
    "locationIncludes": "",
    "includeDescriptions": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/indeed-alternative").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 = {
    "boards": [{
            "source": "greenhouse",
            "slug": "stripe",
        }],
    "maxResults": 100,
    "titleIncludes": "",
    "locationIncludes": "",
    "includeDescriptions": True,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/indeed-alternative").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 '{
  "boards": [
    {
      "source": "greenhouse",
      "slug": "stripe"
    }
  ],
  "maxResults": 100,
  "titleIncludes": "",
  "locationIncludes": "",
  "includeDescriptions": true
}' |
apify call khadinakbar/indeed-alternative --silent --output-dataset

```

## MCP server setup

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

```

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/mBHNtKHOPEmrDNPvj/builds/pMZ9aad2Fv5niYkID/openapi.json