# iCIMS Jobs Scraper — Live Postings API by Company (`accountable_eel/icims-jobs-lookup`) Actor

Look up any company's live iCIMS careers portal and get its open roles — title, location, category, apply link. Filter by title, location, remote, or posted date, or get only postings new since your last run. Charged once per company checked.

- **URL**: https://apify.com/accountable\_eel/icims-jobs-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 successful lookups

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?

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

## iCIMS Jobs Lookup — Live Postings by Company

You paste a list of companies. For each one, this actor looks up their live **iCIMS** careers
portal and returns its open roles — title, location, category, and apply link — as one row per
posting (or one row per company, your choice). No API key, no browser: it reads the portal's own
server-rendered noscript job listing directly, the same fallback iCIMS ships for visitors with
JavaScript disabled. Optional filters narrow the roles you get back by title, location, or posting
date, and an optional delta mode returns only the postings that appeared since your last run, so
you can put a company list on a schedule and get a hiring alert instead of a full re-dump every
time.

### Who it's for

The accountable\_eel catalogue sells company and hiring intelligence columns for outbound and
recruiting. Each actor takes a list of identifiers and returns one flat, stably-named row per
result — the shape a Clay table, an n8n workflow, or an AI agent can consume without
post-processing. Pricing is pay-per-event: a fraction of a cent for a row you actually got, and
nothing at all for a company with no board or no open roles. No seat licence, no monthly minimum,
no credit system to decode.

This actor is part of the ATS family alongside `greenhouse-jobs-lookup`, `lever-jobs-lookup`,
`ashby-jobs-lookup`, and `workday-jobs-lookup` — same input shape (a company identifier), same
per-company billing, same job-filter fields. iCIMS is a large enterprise ATS (used by employers
like Peraton, Utah State University, and Intrepid Solutions) that none of the other actors in this
portfolio, and few actors anywhere on Apify, currently cover.

### Why this one

- **Reaches data the rendered page can't.** iCIMS careers pages are a client-side widget — the
  page you'd normally fetch has zero job rows in its raw HTML, and several tenants additionally
  wall the page behind a "Human Verification" check. This actor instead fetches the same
  `?in_iframe=1` URL iCIMS itself serves to visitors with JavaScript disabled — fully
  server-rendered, no wall, no browser, no proxy.
- **The keyword search is real.** iCIMS' own search box, reachable through this same URL, genuinely
  filters results upstream (verified live: a real keyword narrowed one portal's results from 14 to
  3, a nonsense keyword to 0) rather than serving one cached page regardless of the query.
- **You pay per company, not per job.** A portal with 1,500 open roles and one with 2 both cost one
  `item-lookup` charge. A subdomain with no portal, or zero open roles, is a free miss.
- **Real filters, not a wall of raw fields.** Title keyword include/exclude, location, remote-only,
  and posted-after-date all combine, matching the rest of the ATS family.
- **A delta mode for watching hiring over time.** Turn on `onlyNewSinceLastRun`, put the actor on a
  schedule, and every run after the first returns only postings you haven't seen — a quiet week
  still gets a row, so you can tell "nothing new" from "the run broke."
- **Honest about the page cap.** iCIMS pages results at 50 per screen and never prints an exact
  board-wide total (only "Page 1 of N"). This actor fetches page 1 and says so in `note` and
  `totalPages` rather than pretending to have the whole board — see "What you get."

### What you get

One row per open job posting by default (toggle "One row per job posting" off in the Input tab to
get one row per company instead, with the full job list nested in `jobs`). Every row carries these
fields, whether or not you've turned on filters or delta mode — the columns never move:

| Field | Type / format | Description |
| --- | --- | --- |
| `query` | text | The company value you passed in, unchanged. |
| `found` | boolean | `true` if the company has an iCIMS portal with at least one open role. |
| `status` | text | `OK`, `NOT_FOUND` (no portal, or no open roles), or `BLOCKED` (the portal's Human Verification wall is active for this request). |
| `boardToken` | text | The iCIMS subdomain, extracted from whatever you pasted (bare token or careers URL). |
| `jobCount` | number | How many roles matched, after your filters (and after delta filtering, if `onlyNewSinceLastRun` is on). |
| `totalJobCount` | number | How many roles were on the fetched page before any filtering — up to 50, iCIMS' own page size. |
| `totalPages` | number | How many result pages this portal reports in total. `1` means you saw everything; higher means the company has more open roles than fit on one page (see `note`). |
| `newJobs` | number | How many roles are new since your last scheduled run. Empty unless `onlyNewSinceLastRun` is on. |
| `firstRun` | boolean | `true` if this was the baseline run for this watchlist. Empty unless `onlyNewSinceLastRun` is on. |
| `note` | text | Set when `totalPages` > 1, explaining that this row only covers page 1. Empty otherwise. |
| `jobs` | array | The full list of matching jobs, each with the fields below. Present in every row; it's what gets expanded into separate rows in "one row per job" mode. |
| `title` | text | Job title. |
| `location` | text | Location as the portal lists it (e.g. "US-OH-Dayton", "US-VA-Arlington"). |
| `departments` | array | Category/department name, when this tenant publishes one — iCIMS lets every customer configure its own extra fields, so this is empty on tenants that don't. |
| `remote` | boolean | `true` if the location, title, or a "Telecommute" field reads as remote. |
| `postedAt` | date (ISO) | When the role was posted, parsed from the portal's own absolute timestamp. The portal doesn't publish its timezone, so this is read as UTC and can be off by a few hours from the tenant's real local time. |
| `applyUrl` | link | Direct link to the posting on the portal. |
| `scrapedAt` | date (ISO) | When this actor fetched the row. |

A company with no portal, or zero open roles, comes back as a single `found: false` row and is
never charged.

### Pricing

$4 per 1,000 companies, plus a $0.00005 start fee. Misses (`found:false`) are never charged.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `companies` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~icims-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"companies":["careers-intrepidsolutions"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

Paste one company per line — the iCIMS tenant subdomain (with or without the usual `careers-`
prefix) or the full careers page URL:

```
careers-intrepidsolutions
careers-peraton
touro
```

**🎯 Job filters** — applied here, after the page is fetched, so you can narrow results beyond what
the portal's own search box exposes. They combine with AND across fields and OR within a field:

| Input | What it does |
| --- | --- |
| `titleKeywords` | Keep only titles containing one of these — `["engineer","analyst"]`. |
| `excludeTitleKeywords` | Drop titles containing one of these — `["intern","contract"]`. Applied after the include list. |
| `locations` | Keep only roles whose location mentions one of these. |
| `remoteOnly` | Keep only roles whose location, title, or telecommute field reads as remote. |
| `postedAfter` | Keep only roles first posted on or after this date, e.g. `2026-06-01`. |
| `onlyNewSinceLastRun` | On a schedule, return only postings you haven't seen on a previous run of this exact filter set. A quiet run still returns a `jobCount: 0` row, not silence. |

### Input

```json
{
  "companies": [
    "careers-intrepidsolutions"
  ]
}
```

One company per line — paste the iCIMS tenant subdomain or the full careers page URL, e.g. "careers-intrepidsolutions" or "https://careers-intrepidsolutions.icims.com". Accepted formats: careers-intrepidsolutions, intrepidsolutions, https://careers-intrepidsolutions.icims.com, https://careers-intrepidsolutions.icims.com/jobs/search.

### Output

| query | found | status | boardToken | jobCount | totalJobCount | totalPages | newJobs | firstRun | note | jobs | title | location | departments | remote | postedAt | applyUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| careers-intrepidsolutions | true | OK | careers-intrepidsolutions | 15 | 15 | 1 |  |  | <note> | \<all matching jobs (full list)> | AWS Cloud/Virtual Infrastructure Technician | US-OH-Dayton | \["Information Technology"] | false |  | https://careers-intrepidsolutions.icims.com/jobs/2413/aws-cloud-virtual-infrastructure-technician/job | 2026-08-31T07:00:36.710Z |

A miss comes back as a row with `"found": false` and is never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~icims-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"companies":["careers-intrepidsolutions"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~icims-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"companies":["careers-intrepidsolutions"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~icims-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"companies":["{{company}}"]}`, mapping the row's company into the `companies` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "iCIMS Jobs Lookup | Apify" — the agent will find and run this actor.

### FAQ

**Why was I charged for a company that returned 0 jobs?** Filters (or delta mode) can legitimately
narrow a real result down to zero. The lookup happened and answered the question — `totalJobCount`
shows what was on the page before filtering, so a zero row explains itself.

**Does this actor need a proxy?** No. The `?in_iframe=1` fallback this actor reads is served
directly, no anti-bot handling required — see "Why this one."

**What if a tenant's portal is walled?** A small number of iCIMS tenants gate even this fallback
path behind a "Human Verification" check. That row comes back `status: BLOCKED` and is never
charged.

**Why only page 1?** iCIMS caps each results page at 50 postings and never prints an exact
board-wide total in its markup (only "Page 1 of N"). `totalPages` tells you when there's more than
one page so you know the row is a sample, not the whole board.

**Can I schedule this to alert me on new postings?** Yes — turn on `onlyNewSinceLastRun` and put
the actor on an Apify Task schedule. See "How to use."

**Is this GDPR-relevant?** No personal data is collected — this actor reads public job postings
(title, location, category, apply link), not candidate or employee data.

# Actor input Schema

## `companies` (type: `array`):

One company per line — paste the iCIMS tenant subdomain or the full careers page URL, e.g. "careers-intrepidsolutions" or "https://careers-intrepidsolutions.icims.com". Accepted formats: careers-intrepidsolutions, intrepidsolutions, https://careers-intrepidsolutions.icims.com, https://careers-intrepidsolutions.icims.com/jobs/search. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `titleKeywords` (type: `array`):

Optional. Keep only roles whose title contains at least one of these words — e.g. "engineer", "account executive", "designer". Case doesn't matter, and partial words work ("engineer" matches "Engineering Manager"). Leave empty to keep every role.

## `excludeTitleKeywords` (type: `array`):

Optional. Drop any role whose title contains one of these words — e.g. "intern", "senior", "contract". Applied after the include list above, so a role matching both is dropped.

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

Optional. Keep only roles whose location mentions one of these — e.g. "Virginia", "Dayton", "Remote". Case doesn't matter and partial matches work. Leave empty to keep every location.

## `remoteOnly` (type: `boolean`):

Keep only roles whose location, title, or telecommute field says remote. Companies label remote work inconsistently, so treat this as a strong filter, not a guarantee.

## `postedAfter` (type: `string`):

Optional. A date like 2026-06-01 (or a full timestamp). Keeps only roles this portal first posted on or after it. Leave empty for no date limit.

## `onlyNewSinceLastRun` (type: `boolean`):

Turn this on for a scheduled watchlist: the first run returns everything that matches and remembers it, and every run after that returns only postings it hasn't shown you before. A company with nothing new still gets a row (with 0 jobs), so a quiet schedule never looks like a broken one. Changing the filters above starts a fresh watchlist.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each job posting found gets its own row instead of being grouped under its company. You're still only charged once per company, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "companies": [
    "careers-intrepidsolutions"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "locations": [],
  "remoteOnly": false,
  "postedAfter": "",
  "onlyNewSinceLastRun": false,
  "columns": [
    "boardToken",
    "jobCount",
    "totalJobCount",
    "totalPages",
    "newJobs",
    "firstRun",
    "note",
    "jobs",
    "title",
    "location",
    "departments",
    "remote",
    "postedAt",
    "applyUrl"
  ],
  "expandRows": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "companies": [
        "careers-intrepidsolutions"
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "locations": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/icims-jobs-lookup").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 = {
    "companies": ["careers-intrepidsolutions"],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "locations": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/icims-jobs-lookup").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 '{
  "companies": [
    "careers-intrepidsolutions"
  ],
  "includeKeywords": [],
  "excludeKeywords": [],
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "locations": []
}' |
apify call accountable_eel/icims-jobs-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/icims-jobs-lookup"
        }
    }
}

```

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/YAVcHTwstvUPmC72g/builds/yu9hdC6vakcAmSDmF/openapi.json