# iCIMS Scraper \[$1.5/1K💰] | Career Sites | Job Postings (`ahmed_jasarevic/icims-scraper`) Actor

Extract job postings from any iCIMS-powered career site: title, company, location, coordinates, employment type, salary, dates, full description, apply URL, requisition ID and skills. Built for recruiting intelligence, competitor hiring analysis and job-aggregation datasets. $1.50 per 1,000 jobs.

- **URL**: https://apify.com/ahmed_jasarevic/icims-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 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.
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

## iCIMS Scraper

Extract live job postings from any **iCIMS-powered career site** — title, company, location with coordinates, employment type, salary, posted and closing dates, full description (HTML + plain text), apply URL, requisition ID and skills — with no iCIMS partnership or credentials required.

Built for recruiting-intelligence teams, competitor hiring analysis, talent-market research and job aggregators that need structured ATS job data.

### Aggregate Job Postings Across iCIMS Career Sites

- **Job-aggregation datasets** — normalize postings from thousands of `careers-*.icims.com` portals into one schema.
- **Competitor hiring intelligence** — track which roles employers open, where, and when they close.
- **Recruiting & sourcing research** — requisition IDs, apply URLs, skills arrays and salary text (when published) per posting.
- **Talent-market analysis** — employment type, category, location details and geo coordinates for mapping hiring demand.
- **ATS migration monitoring** — watch a company's public pipeline of open roles over time on a schedule.
- **Feeds for AI agents** — clean JSON per job, ready for RAG indexes or job-matching apps.

### How It Works

![How the iCIMS Scraper works: career-site HTML and JSON-LD become job rows with locations, dates, skills and apply links.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-icims-scraper)

iCIMS career sites serve fully rendered HTML through the first-party `?in_iframe=1` parameter. A CheerioCrawler reads the embedded schema.org JobPosting JSON-LD, falls back to HTML for salary, category and apply URL, then follows pagination and deduplicates.

Each row covers one requisition with 17 fields including title, company, location details, coordinates, employment type, posted and closing dates, skills, description text and apply URL.

iCIMS career sites serve fully server-rendered HTML through a first-party presentation parameter (`?in_iframe=1`) — the same fallback iCIMS provides to visitors with JavaScript disabled. A CheerioCrawler (plain HTTP, no browser) fetches that HTML and then:

1. Parses the embedded **JSON-LD (`schema.org JobPosting`)** block on detail pages — the primary source for structured metadata.
2. Falls back to **HTML parsing** for fields JSON-LD does not expose (salary, categories, apply URL) and for job cards on search pages.
3. Follows pagination automatically and deduplicates jobs per run.

Because the endpoint is plain server-rendered HTML — not a JavaScript app and not behind an interactive challenge — runs are fast and cheap (~500 ms per detail page, 256 MB is plenty). An optional proxy input is available for geo-restricted setups.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `startUrls` | array | No | `https://careers-here.icims.com/jobs/search` | iCIMS career-site URLs. Base URLs, `/jobs/search` and `/careers-home` are all normalized automatically. Leave empty to use the default demo tenant. |
| `maxRequestsPerCrawl` | integer | No | `100` | Page budget; each job detail page counts as one request. |
| `maxJobsPerPage` | integer | No | `0` | Max detail pages per search-results page (`0` = unlimited). |
| `searchKeyword` | string | No | `""` | Keyword filter applied via the site's search form (e.g. `engineer`). |
| `searchLocation` | string | No | `""` | Location filter — must exactly match a value from the site's location dropdown. |
| `searchCategory` | string | No | `""` | Category filter — must exactly match a value from the site's category dropdown. |
| `proxy` | object | No | direct | Standard Apify proxy configuration. Only needed for geo-restricted sites; use a US exit IP in that case. |

Supported URL shapes: `https://careers-company.icims.com` (auto-appends `/jobs/search`), `…/jobs/search`, `…/careers-home` (auto-redirects), or any iCIMS tenant subdomain / vanity domain.

### Output Fields

One object per job (17 fields):

| Field | Description |
| --- | --- |
| `title` | Job title |
| `company` | Employer name |
| `location` | Raw location string (e.g. `IN-Mumbai`) |
| `locationDetails` | `streetAddress`, `addressLocality`, `addressRegion`, `postalCode`, `addressCountry` |
| `coordinates` | `latitude` / `longitude` when the employer publishes geo data |
| `category` | Job category from the site (e.g. `Product & Engineering`) |
| `employmentType` | e.g. `FULL_TIME`, `OTHER` |
| `salary` | Salary text when disclosed in the posting's structured data |
| `postedDate`, `validThrough` | ISO posting and closing dates |
| `description` | Full job description as HTML |
| `descriptionText` | Same description as plain text |
| `applyUrl` | Direct application link |
| `requisitionId` | Employer requisition / job ID |
| `skills` | Skills array when published (e.g. `["Python","Agile"]`) |
| `sourceUrl` | Canonical detail-page URL |
| `scrapedAt` | Extraction timestamp |

### Example Input

Minimal — scrapes the default demo tenant:

```json
{}
```

A real company's iCIMS portal with filters:

```json
{
  "startUrls": [{ "url": "https://careers-company.icims.com" }],
  "searchKeyword": "engineer",
  "searchLocation": "United States",
  "searchCategory": "Engineering",
  "maxRequestsPerCrawl": 200
}
```

### Example Output

```json
{
  "title": "Sr Technical PM Specialist",
  "company": "HERE Technologies",
  "location": "IN-Mumbai",
  "locationDetails": {
    "streetAddress": "10th FL, Nesco IT Park, Nesco Complex",
    "addressLocality": "Mumbai",
    "addressRegion": "UNAVAILABLE",
    "postalCode": "400063",
    "addressCountry": "IN"
  },
  "coordinates": { "latitude": 19.076, "longitude": 72.8777 },
  "category": "Product & Engineering",
  "employmentType": "OTHER",
  "salary": "",
  "postedDate": "2026-10-16T04:00:00.000Z",
  "validThrough": "2027-10-16T04:00:00.000Z",
  "description": "<h2>What's the role?</h2>…",
  "descriptionText": "What's the role? The role of a Technical Product Manager…",
  "applyUrl": "https://careers-here.icims.com/jobs/83683/...?mode=apply&apply=yes",
  "requisitionId": "2026-83683",
  "skills": ["Python", "Go", "Git", "Jira", "Agile"],
  "sourceUrl": "https://careers-here.icims.com/jobs/83683/sr-technical-pm-specialist/job",
  "scrapedAt": "2026-10-18T07:48:19.300Z"
}
```

### Automate Hiring-Pipeline Monitoring With Schedules & Webhooks

- **Schedule** daily runs on a competitor's portal to capture newly opened and expired roles.
- **Webhooks** deliver run-completion events into your ATS, CRM, Slack or data warehouse.
- **API / MCP** — start runs and pull datasets from any pipeline or AI agent.
- **Cost control** — free accounts are limited to 10 jobs per run; paid accounts run the full configuration at `$1.50` per 1,000 jobs.

### Related Actors

Verified related actors on Apify that pair well with this one. All links point to real, publicly available actors.

- [Greenhouse, Lever & Ashby Job Scraper API | $1.50/1K](https://apify.com/bovi/greenhouse-lever-ashby-job-scraper)
- [Greenhouse, Lever & Ashby Jobs Scraper — with Salaries](https://apify.com/viridian_layout_ea2/company-career-site-jobs)
- [iCIMS Jobs API](https://apify.com/fantastic-jobs/icims-jobs-api)
- [iCIMS Jobs Scraper](https://apify.com/hirebase/icims-jobs)
- [iCIMS API | Live Jobs from iCIMS Career Sites](https://apify.com/johnvc/icims-careers-api)

### Frequently Asked Questions

#### Does iCIMS have an official API?

Yes, but it is partner-gated. The iCIMS Talent Cloud API and Job Portal API live behind the iCIMS Partner Program: you apply, normally need a sponsoring iCIMS customer, and receive per-customer credentials — there is no self-service API key, no public sandbox and no public OpenAPI spec. iCIMS also runs a standard XML feed, but access requires vendor onboarding and OAuth approval, and each customer can opt their jobs out of any board. This Actor needs none of that: it reads the public career portals (`careers-*.icims.com` and vanity domains) that every iCIMS customer gets for free.

#### What are alternatives to iCIMS for public job data?

Greenhouse publishes a free public Job Board API per board, Lever exposes a public postings endpoint (`api.lever.co/v0/postings/{company}`) and Ashby serves public jobs JSON — all without auth. Since real-world hiring spans many ATS platforms at once, most teams combine an iCIMS scraper (this Actor) with the Greenhouse/Lever/Ashby scrapers linked in Related Actors.

#### Can I filter jobs by keyword, location or category?

Yes — `searchKeyword`, `searchLocation` and `searchCategory` are applied through each portal's own search form. Location and category values must exactly match the dropdown values that specific career site publishes (they differ per tenant).

#### Which URL formats does the Actor accept?

Base URLs (`https://careers-company.icims.com`), explicit search URLs (`…/jobs/search`), `…/careers-home` (redirected automatically), and arbitrary iCIMS tenant subdomains or vanity domains that proxy iCIMS underneath.

#### How much does it cost?

`$1.50` per 1,000 jobs stored, pay per event — a 500-job run costs about $0.75. Free Apify accounts are limited to 10 jobs per run.

#### Can an AI agent call this Actor?

Yes — JSON input through the Apify API and MCP server; `{}` even works as a minimal call against the default demo tenant. See [For AI Agents & LLM Apps](#for-ai-agents--llm-apps).

#### Do I need proxies?

Mostly no — the server-rendered endpoint answers plain HTTP. Set the `proxy` input (US exit IP) only for geo-restricted career sites.

### For AI Agents & LLM Apps

Returns structured job postings from iCIMS-powered career sites in one normalized schema.

Minimal input (defaults to the demo tenant):

```json
{}
```

Typical input (a real employer portal):

```json
{ "startUrls": [{ "url": "https://careers-here.icims.com" }], "maxRequestsPerCrawl": 100 }
```

Output fields: `title`, `company`, `location`, `locationDetails`, `coordinates`, `category`, `employmentType`, `salary`, `postedDate`, `validThrough`, `description`, `descriptionText`, `applyUrl`, `requisitionId`, `skills`, `sourceUrl`, `scrapedAt`.

Behaviors an agent should know:

- With empty/omitted `startUrls` the Actor scrapes `https://careers-here.icims.com/jobs/search` (a demo tenant) — always pass a real careers URL for production use.
- `searchLocation` / `searchCategory` must match the target site's dropdown values exactly or they silently return unfiltered results.
- `maxJobsPerPage: 0` means unlimited per search page; `maxRequestsPerCrawl` is the real budget knob (1 per detail page).
- `salary`, `coordinates` and `skills` are only present when the employer publishes them in the posting's JSON-LD.
- Free Apify accounts are capped at 10 jobs per run.
- Proxies are optional; set one only for geo-restricted sites.

Billing: pay per event — `$0.0015` per job stored (`apify-default-dataset-item`).

### Legal & Compliance Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by iCIMS, Inc. or the iCIMS Talent Cloud. It accesses only publicly available career-portal pages — no login, no authenticated areas and no credentials of any kind. Job-posting data returned (titles, employers, locations, requisition IDs, descriptions) is what each employer already publishes to every visitor of its careers site; salary and contact fields appear only where the employer discloses them. You are responsible for your own compliance with the source sites' Terms of Service and with applicable data-protection law; where personal data appears inside job descriptions, handle it under GDPR/CCPA rules and do not use it for unsolicited commercial outreach in violation of applicable law.

### SEO Keywords

icims scraper, icims api, icims career site scraper, scrape icims jobs, icims jobs data, ats job postings, job posting data, career site scraper, job aggregator data, recruiting intelligence, competitor job openings, job posting database, hiring data, job listing api, corporate job postings, recruitment data, job market data, job feed data

# Actor input Schema

## `startUrls` (type: `array`):

URLs of iCIMS career sites to scrape. Accepts base URLs like https://careers-here.icims.com or search URLs like https://careers-here.icims.com/jobs/search. The actor will automatically use the ?in_iframe=1 bypass for server-rendered HTML. Optional: if left empty, the actor defaults to https://careers-here.icims.com/jobs/search (optionally combined with the search filters below).

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of requests (pages + job details) to process. Each job detail page counts as one request.

## `maxJobsPerPage` (type: `integer`):

Maximum number of job detail pages to scrape per search results page. Use 0 for no limit.

## `searchKeyword` (type: `string`):

Optional keyword to filter jobs (e.g., 'engineer', 'manager'). Applied via the search form.

## `searchLocation` (type: `string`):

Optional location filter (e.g., 'Mumbai', 'Berlin', 'United States'). Must match a value from the site's location dropdown.

## `searchCategory` (type: `string`):

Optional category filter (e.g., 'Engineering', 'Sales'). Must match a value from the site's category dropdown.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://careers-here.icims.com/jobs/search"
    }
  ],
  "maxRequestsPerCrawl": 100,
  "maxJobsPerPage": 0,
  "searchKeyword": "",
  "searchLocation": "",
  "searchCategory": "",
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://careers-here.icims.com/jobs/search"
        }
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/icims-scraper").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 = {
    "startUrls": [{ "url": "https://careers-here.icims.com/jobs/search" }],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/icims-scraper").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 '{
  "startUrls": [
    {
      "url": "https://careers-here.icims.com/jobs/search"
    }
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/icims-scraper --silent --output-dataset

```

## MCP server setup

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

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/9ZM9f6AuNbdeoXbLl/builds/EKhncld1fNkwBvCit/openapi.json