# iHire Jobs Scraper (`piotrv1001/ihire-jobs-scraper`) Actor

The iHire Jobs Scraper extracts job listings from iHire's 50+ industry job boards, capturing job titles, companies, locations, salaries, skills, benefits, education and experience requirements, coordinates, and full descriptions — ideal for salary research, recruitment sourcing, and job aggregation.

- **URL**: https://apify.com/piotrv1001/ihire-jobs-scraper.md
- **Developed by:** [FalconScrape](https://apify.com/piotrv1001) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job listings

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### 🚀 iHire Jobs Scraper

Extract **job listings from [iHire](https://www.ihire.com)** — the network of 50+ industry-specific job boards — with a single click. The **iHire Jobs Scraper** collects structured job data including **salaries, required skills, benefits, education and experience requirements, company details, and full job descriptions**, ready to export as JSON, CSV, or Excel.

Run it on demand, on a schedule, or via the Apify API, and let the platform handle proxies, retries, and scaling for you.

### ✨ What does iHire Jobs Scraper do?

- 🔍 **Keyword search** – Find jobs by job title (e.g. `nurse`, `paralegal`, `engineer`), or leave it empty to scrape across every job title on iHire.
- 💰 **Rich salary data** – Capture base salary, currency, and pay period (hourly / yearly) straight from the source.
- 🧠 **Skills & benefits** – Get the full list of required skills and offered benefits for each role.
- 🏢 **Company & location** – Employer name, logo, city, state, ZIP code, and geo coordinates.
- 📄 **Full descriptions** – Pull the complete job description, employment type, and education/experience requirements when detailed mode is enabled.
- ⚡ **Two cost tiers** – Pay a low price for quick listings, or enable full detail extraction only when you need the deep data.

### 💼 Why use iHire Jobs Scraper?

- **Job market & salary research** – Benchmark compensation, benefits, and in-demand skills across 50+ industry verticals.
- **Recruitment & sourcing** – Build pipelines of open roles and hiring companies by niche.
- **Lead generation** – Identify employers who are actively hiring in your target industry.
- **Aggregation** – Feed fresh, structured job postings into your own job board or data product.

### 🛠️ How to use iHire Jobs Scraper

1. **Enter a job title keyword** – For example `nurse` or `paralegal` (or leave it empty for all titles).
2. **Choose detail level** – Toggle **Scrape full job details** on for salaries, skills, benefits, and full descriptions.
3. **Set the max items** – Decide how many jobs you want.
4. **Run the Actor** – Click **Start** and watch results stream into the dataset in real time.
5. **Export** – Download your data as JSON, CSV, Excel, or pull it through the Apify API.

### 📥 Input

| Field                       | Description                                                                                               |
| --------------------------- | --------------------------------------------------------------------------------------------------------- |
| **Job title keyword**       | Filters jobs by job title. Leave empty to scrape across all titles.                                       |
| **Scrape full job details** | When enabled, fetches salary, skills, benefits, requirements, geo, and the full description for each job. |
| **Max items**               | Maximum number of jobs to scrape.                                                                         |
| **Proxy configuration**     | Residential US proxies are used by default and recommended.                                               |

Example input:

```json
{
    "keyword": "nurse",
    "scrapeDetails": true,
    "maxItems": 50
}
````

### 📊 Output

Each job is saved as a structured record in the dataset. You can download it in JSON, CSV, Excel, or HTML.

Example output (full detail mode):

```json
{
    "jobId": "525464636",
    "title": "Collections Paralegal / Legal Assistant III",
    "company": "FSA Federal",
    "companyLogo": "https://.../small.jpeg",
    "employmentType": "FULL_TIME",
    "datePosted": "2026-06-19 01:19",
    "validThrough": "2027-06-19 01:19",
    "salaryCurrency": "USD",
    "salaryAmount": 34.86,
    "salaryUnit": "HOUR",
    "benefits": ["Health Insurance", "Dental Insurance", "401(k)", "Paid Time Off"],
    "skills": ["Microsoft Office", "Legal Research & Writing", "Litigation", "Documentation"],
    "industry": "Legal",
    "education": "High School or GED",
    "monthsOfExperience": null,
    "city": "Raleigh",
    "state": "NC",
    "postalCode": "27601",
    "country": "US",
    "latitude": 35.77521,
    "longitude": -78.63432,
    "directApply": false,
    "description": "Introduction Welcome to ...",
    "url": "https://www.ihire.com/jobs/view/525464636",
    "source": "ihire.com",
    "scrapedAt": "2026-06-19T12:00:00.000Z"
}
```

#### Data fields

| Field                                            | Description                           |
| ------------------------------------------------ | ------------------------------------- |
| `jobId`                                          | Unique iHire job ID                   |
| `title`                                          | Job title                             |
| `company`                                        | Hiring company name                   |
| `companyLogo`                                    | Company logo URL                      |
| `employmentType`                                 | Full-time, part-time, contract, etc.  |
| `datePosted` / `validThrough`                    | Posting and expiry dates              |
| `salaryAmount` / `salaryCurrency` / `salaryUnit` | Base salary, currency, and pay period |
| `benefits`                                       | List of offered benefits              |
| `skills`                                         | List of required skills               |
| `industry`                                       | Industry vertical                     |
| `education`                                      | Required education / credential       |
| `monthsOfExperience`                             | Required experience in months         |
| `city` / `state` / `postalCode` / `country`      | Job location                          |
| `latitude` / `longitude`                         | Geo coordinates                       |
| `directApply`                                    | Whether direct apply is available     |
| `description`                                    | Full job description                  |
| `url`                                            | Link to the job posting               |

### 💵 Pricing

This Actor uses the **pay-per-event** pricing model — you only pay for the data you extract:

| Event           | Price                    | What you get                                                          |
| --------------- | ------------------------ | --------------------------------------------------------------------- |
| **Job listing** | **$1.00 per 1,000 jobs** | Title, company, location, and snippet                                 |
| **Job detail**  | **$3.00 per 1,000 jobs** | Salary, skills, benefits, requirements, geo, and the full description |

Keep **Scrape full job details** off for cheap, fast listings; turn it on only when you need the deep data. With the Apify free tier you can try the Actor at no cost.

### 💡 Tips

- Start with a small **Max items** value to preview the data shape, then scale up.
- Leave **keyword** empty to sweep across all 1,000+ job titles for broad coverage.
- Schedule runs to keep a fresh feed of new postings in your industry.

### ❓ FAQ

**Is scraping iHire legal?**
This Actor collects only publicly available job-posting data. As with any scraping, make sure your use complies with iHire's Terms of Service and applicable laws. It does not collect personal or private data.

**Why are some jobs missing salary or skills?**
Those fields come from full detail mode. Enable **Scrape full job details** to capture them.

**Can I get results for a specific location?**
The current version filters by job title. Location filtering is on the roadmap — open an issue on the Actor's **Issues** tab to request it.

**Something isn't working — where do I report it?**
Use the **Issues** tab on the Actor's page. Custom requirements? Reach out and we can help.

***

Start extracting structured job data from **iHire** today! 🚀

# Actor input Schema

## `keyword` (type: `string`):

Filters jobs by job title (e.g. "nurse", "paralegal", "engineer"). Leave empty to scrape across all job titles.

## `scrapeDetails` (type: `boolean`):

Fetch the full job posting for each result, including salary, skills, benefits, education and experience requirements, geo coordinates, and the complete job description. When off, only the listing-level fields are returned.

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

Maximum number of jobs to scrape.

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

Residential US proxies are used by default and are required for this Actor to work reliably.

## Actor input object example

```json
{
  "keyword": "nurse",
  "scrapeDetails": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "keyword": "nurse"
};

// Run the Actor and wait for it to finish
const run = await client.actor("piotrv1001/ihire-jobs-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 = { "keyword": "nurse" }

# Run the Actor and wait for it to finish
run = client.actor("piotrv1001/ihire-jobs-scraper").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 '{
  "keyword": "nurse"
}' |
apify call piotrv1001/ihire-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=piotrv1001/ihire-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iHire Jobs Scraper",
        "description": "The iHire Jobs Scraper extracts job listings from iHire's 50+ industry job boards, capturing job titles, companies, locations, salaries, skills, benefits, education and experience requirements, coordinates, and full descriptions — ideal for salary research, recruitment sourcing, and job aggregation.",
        "version": "0.0",
        "x-build-id": "wXWpqx2eLHeAF6miX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piotrv1001~ihire-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piotrv1001-ihire-jobs-scraper",
                "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/piotrv1001~ihire-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-piotrv1001-ihire-jobs-scraper",
                "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/piotrv1001~ihire-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-piotrv1001-ihire-jobs-scraper",
                "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",
                "properties": {
                    "keyword": {
                        "title": "Job title keyword",
                        "type": "string",
                        "description": "Filters jobs by job title (e.g. \"nurse\", \"paralegal\", \"engineer\"). Leave empty to scrape across all job titles.",
                        "default": ""
                    },
                    "scrapeDetails": {
                        "title": "Scrape full job details",
                        "type": "boolean",
                        "description": "Fetch the full job posting for each result, including salary, skills, benefits, education and experience requirements, geo coordinates, and the complete job description. When off, only the listing-level fields are returned.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of jobs to scrape.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential US proxies are used by default and are required for this Actor to work reliably.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
