# HospitalCareers.com Scraper (`lexis-solutions/hospitalcareers-com-scraper`) Actor

HospitalCareers.com jobs scraper for healthcare job listings, talent intelligence, and salary benchmarking. Extracts hospital job data (title, employer, salary, location, posting date) for recruitment analytics and job market research.

- **URL**: https://apify.com/lexis-solutions/hospitalcareers-com-scraper.md
- **Developed by:** [Lexis Solutions](https://apify.com/lexis-solutions) (community)
- **Categories:** Jobs, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

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

![banner](https://i.ibb.co/RGg58m3h/hospitalcareers.png)

## HospitalCareers.com Scraper

HospitalCareers.com is a dedicated healthcare job board connecting thousands of medical professionals with hospitals, health systems, and healthcare organizations across the United States. The platform hosts listings for nursing, therapy, pharmacy, counseling, and a wide range of clinical and administrative roles.

### Introduction

This Apify scraper extracts structured job listing data from HospitalCareers.com without requiring an API key or account. Provide one or more search URLs and the scraper will collect role metadata, employer details, location information, employment type, and posting timelines for each listing.

### Use Cases

- **Healthcare talent intelligence**: Monitor open roles across hospitals and health systems to track hiring demand by specialty or region.
- **Salary benchmarking**: Collect compensation data from postings to benchmark pay across healthcare roles and geographies.
- **Competitive analysis**: Track which employers are hiring for specific roles and how quickly positions turn over.
- **Job market research**: Analyze trends in healthcare hiring, including the most in-demand specialties and locations.

### Input

Provide the following fields:

- `startUrls` (array, required): Search URLs from hospitalcareers.com (e.g., `https://hospitalcareers.com/jobs/?q=nurse&l=`) or direct job detail URLs
- `maxItems` (integer, optional): Maximum number of job listings to scrape per start URL (default: 5)
- `proxyConfiguration` (object, optional): Proxy settings for the scraper

### Input Examples

**1) Search for nurses in any location**

```json
{
  "startUrls": [{ "url": "https://hospitalcareers.com/jobs/?q=nurse&l=" }],
  "maxItems": 20
}
````

**2) Search for pharmacists in Texas**

```json
{
  "startUrls": [
    { "url": "https://hospitalcareers.com/jobs/?q=pharmacist&l=Texas" }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

**3) Multiple search queries**

```json
{
  "startUrls": [
    { "url": "https://hospitalcareers.com/jobs/?q=doctor&l=" },
    { "url": "https://hospitalcareers.com/jobs/?q=therapist&l=" }
  ],
  "maxItems": 15
}
```

### Output

Each dataset item contains fields like:

```json
{
  "jobId": "10646080",
  "title": "Clinical Psychologist Post-Doctoral Fellow",
  "employer": "LifeStance Health",
  "location": "South Kingstown, RI",
  "employmentType": "Full Time",
  "category": "Counseling",
  "postedDate": "May 01, 2026",
  "salary": "$58,000",
  "description": "At LifeStance Health, we believe in a truly healthy society...",
  "url": "https://hospitalcareers.com/job/10646080/clinical-psychologist-post-doctoral-fellow/"
}
```

### Why use the HospitalCareers.com Scraper?

- **Fast**: Uses lightweight HTML parsing — no browser required, runs efficiently at scale.
- **Easy to use**: Just paste any search URL from the site and set your item limit.
- **Reliable**: Handles pagination automatically, retries failed requests, and respects per-URL item limits.
- **Well-Maintained**: Built and maintained by a certified Apify Partner with a track record of 180+ production scrapers.

### FAQ

- **Do I need a proxy to use this scraper?**

  Yes — HospitalCareers.com blocks non-US requests on pages beyond the first, so pagination silently stops without a US residential proxy. The scraper defaults to Apify's US residential proxy pool. Disabling this will cause runs to stop after the first page (20 results) regardless of your `maxItems` setting.

- **Do I need a HospitalCareers account to use this scraper?**

  No, the scraper works without any account or API key.

- **How many items can I scrape?**

  There is no hard limit. Use the `maxItems` field to control the number of results per start URL.

- **Is this scraper compliant with HospitalCareers' terms?**

  This scraper accesses only publicly available data. Always review the website's terms of service before scraping.

### Need to scrape other job sites?

Check out our other scrapers for similar websites:

- [CareerBuilder Scraper](https://apify.com/lexis-solutions/careerbuilder-com-scraper)
- [Totaljobs Scraper](https://apify.com/lexis-solutions/totaljobs-scraper)
- [Jobcase Scraper](https://apify.com/lexis-solutions/jobcase-scraper)

***

Got feedback or need an extension?

Lexis Solutions is a [certified Apify Partner](https://apify.com/partners/find).
We can help you with custom solutions or data extraction projects.

Contact us over [Email](mailto:scraping@lexis.solutions) or
[LinkedIn](https://www.linkedin.com/company/lexis-solutions)

### Support Our Work

If you're happy with our work and scrapers, you're welcome to leave us a
company review [here](https://apify.com/partners/find/lexis-solutions/review)

### Image Credit

Image credit: [hospitalcareers.com](https://www.hospitalcareers.com/)

# Actor input Schema

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

Search or job listing URLs from hospitalcareers.com to start scraping from.

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

Maximum number of job listings to scrape per start URL.

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

Select proxies to be used by your crawler. US residential proxies are required for reliable pagination — the site blocks non-US requests on pages beyond the first.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://hospitalcareers.com/jobs/?q=nurse&l="
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (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://hospitalcareers.com/jobs/?q=nurse&l="
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/hospitalcareers-com-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://hospitalcareers.com/jobs/?q=nurse&l=" }] }

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/hospitalcareers-com-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 '{
  "startUrls": [
    {
      "url": "https://hospitalcareers.com/jobs/?q=nurse&l="
    }
  ]
}' |
apify call lexis-solutions/hospitalcareers-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HospitalCareers.com Scraper",
        "description": "HospitalCareers.com jobs scraper for healthcare job listings, talent intelligence, and salary benchmarking. Extracts hospital job data (title, employer, salary, location, posting date) for recruitment analytics and job market research.",
        "version": "1.0",
        "x-build-id": "IYvOGK8JXjd11V8hs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lexis-solutions~hospitalcareers-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lexis-solutions-hospitalcareers-com-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/lexis-solutions~hospitalcareers-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lexis-solutions-hospitalcareers-com-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/lexis-solutions~hospitalcareers-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lexis-solutions-hospitalcareers-com-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Search or job listing URLs from hospitalcareers.com to start scraping from.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum number of items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape per start URL.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your crawler. US residential proxies are required for reliable pagination — the site blocks non-US requests on pages beyond the first.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```