# GovJobs Scraper Fast | Government Jobs | Salaries | US (`ahmed_jasarevic/governmentjobs-scraper`) Actor

Scrape US government jobs from governmentjobs.com (NEOGOV) - job title, agency, location, salary range, closing date, job type, full description and application URL. Pay-per-result at $0.005/job. Ideal for public-sector hiring research, salary benchmarking and government job databases.

- **URL**: https://apify.com/ahmed\_jasarevic/governmentjobs-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 $4.70 / 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

## Governmentjobs Scraper — US Government Jobs, Public Sector Salaries (& Only $0.005/Job💰)

### What does Governmentjobs Scraper do?

**Governmentjobs Scraper** extracts structured job listings from [governmentjobs.com](https://www.governmentjobs.com) — the NEOGOV-powered job board that posts job openings for thousands of US public-sector employers: cities, counties, states, federal-adjacent agencies, school districts, police departments and transit authorities. It is the largest public sector job board in the US and the natural complement to federal-only boards like USAJOBS.

For every job, the actor returns **job title, agency, location, salary range, closing date, job type, full description and application URL** — plus structured extras such as job number, department, opening date, posted date and numeric salary bounds. All data comes from the site's public, server-rendered pages and the embedded JSON-LD `JobPosting` structured data — no browser, no login, no private API.

It runs on the **Apify platform**, so you get API access, scheduling, proxy rotation, monitoring and integrations (Zapier, Make, Google Sheets, Slack) out of the box. Try it with a keyword like `police` or `nurse` and get clean data in seconds. **Pay only $0.005 per job result** — no subscription, no minimum.

### Main Use Cases

- **Public sector hiring research** — quantify how many city, county and state agencies are hiring, in which roles and at what pay, backed by data from the US's largest government job board.
- **Government jobs database** — assemble a searchable database of state/local government openings with structured titles, agencies, locations, closing dates and application links.
- **Salary benchmarking** — compare salary ranges for comparable roles (police, nursing, IT, admin, teaching) across agencies, cities and states using the numeric `salaryMin`/`salaryMax` fields.
- **Workforce planning** — monitor openings, closing dates and compensation by department to support headcount, recruitment and budget planning for agencies and consultants.
- **Civil service job market analysis** — study the civil service labour market over time: opening volumes, hard-to-fill roles (police, engineering, utilities) and hiring trends.

### How It Works

1. You provide optional filters: `keyword`, `location`, `category` or `organization` — leave them empty to browse everything currently posted.
2. The actor crawls the public server-rendered search endpoint (`governmentjobs.com/jobs?keyword=…&location=…`) using a fast **CheerioCrawler** (plain HTTP, no browser), pre-seeding search pages so discovery stays parallel.
3. Each job detail page is parsed for the embedded JSON-LD `JobPosting` structured data plus the human-readable term blocks (Salary, Closing Date, Job Type, Department…).
4. Every job is written to the default dataset as one clean JSON item you can download as JSON, CSV, Excel or HTML, or fetch via the Apify API.

The actor uses up to 40 parallel requests with IP-rotating sessions, retries blocked requests, and respects the site's public endpoint. The Apify proxy is **enabled by default** because governmentjobs.com hangs on Apify's direct datacenter IP — keep it on for cloud runs.

### Track Public Sector Hiring Trends in the US

Public-sector recruiting is under structural pressure — and the data is public. NEOGOV's own analysis of **over 45 million government job applications** shows that between 2019 and 2023, openings for police officers grew ~40% while applications per posting fell ~39%. An estimated mass-retirement wave ("Silver Tsunami") and competition with private-sector salaries are driving a rise in open positions across law enforcement, engineering, utilities and trades.

Use this actor to track that trend yourself:

- Run it **daily or weekly** with a keyword like `police`, `nurse`, `engineer` or `teacher` and see how opening counts and salary bands change over time.
- Compare pay across agencies in the same metro area using the structured `salaryRange`, `salaryMin` and `salaryMax` fields.
- Identify continuous-recruitment postings with no closing date (`closingDate = null`) — a strong signal of hard-to-fill roles.

Because each result costs only $0.005, a 200-job national snapshot costs about **$1** — cheap enough to run on a schedule for months.

### Build Government & Municipal Job Databases

governmentjobs.com is where city clerks, county sheriffs, school districts, transit agencies and state departments all post the same job to a shared board with a **single application URL per posting** (`governmentjobs.com/jobs/{jobId}/{slug}/apply`). That makes it ideal for building a municipal and state job database:

- Each record is a flat JSON item — easy to load into a database, spreadsheet or search index.
- The `url`, `jobNumber`, `department`, `openingDate`, `datePosted` and `applicationUrl` fields give you full provenance per posting.
- Combine it with the federal **USAJOBS** actors on Apify Store to cover both the state/local and federal job markets in one pipeline.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `keyword` | string | `""` | Search keyword to filter jobs by title (e.g. `police`, `nurse`, `engineer`). Empty = all jobs. |
| `location` | string | `""` | Location filter (e.g. `Seattle, WA`, `Texas`, `California`). |
| `category` | string | `""` | Job category filter (e.g. `Public Safety`). |
| `organization` | string | `""` | Organization / agency filter (e.g. `City of Seattle`). |
| `maxItems` | integer | `50` | Max job **detail** pages to scrape. The actor crawls search pages (up to 10 jobs each) until this limit is reached. Min `1`, max `2000`. |
| `proxy` | object | `{ "useApifyProxy": true }` | Standard Apify proxy configuration. **Enabled by default** — required on cloud because the site blocks Apify's direct datacenter IP. |

> **Cost control for pay-per-event:** `maxItems` caps the number of results — and with $0.005 per result it caps your spend. Always set it before a run.

### Output

Each dataset item is **one job**. Fields (23):

| Field | Type | Description |
| --- | --- | --- |
| `jobId` | string | NEOGOV job identifier |
| `jobTitle` | string | Job title |
| `agency` | string | Hiring organization / agency |
| `location` | string | Job location (street-level when available) |
| `salaryRange` | string | Human-readable salary range |
| `closingDate` | string|null | Application closing date (null for continuous recruitment) |
| `jobType` | string | Employment type (e.g. Full-Time, Part-Time) |
| `fullDescription` | string | Full job description as HTML |
| `descriptionText` | string | Full job description as plain text |
| `applicationUrl` | string | Direct application link |
| `url` | string | Job detail page URL |
| `jobNumber` | string|null | Agency job reference number |
| `department` | string|null | Department within the agency |
| `openingDate` | string|null | Posting opening date |
| `datePosted` | string|null | Structured posted date (ISO) |
| `employmentType` | string|null | Schema.org employment type (e.g. FULL\_TIME) |
| `salaryMin` / `salaryMax` | number|null | Numeric salary bounds |
| `salaryCurrency` | string|null | Salary currency (e.g. USD) |
| `salaryUnit` | string|null | Salary unit (e.g. YEAR, HOUR) |
| `featured` | boolean | Whether the job is featured on the board |
| `closingInfo` | string|null | Closing hint from search results (e.g. "Closes in 1 week") |

Download the dataset as **JSON, CSV, Excel or HTML** from the Dataset tab, or fetch it via the Apify API.

### Example Input JSON

```json
{
  "keyword": "police",
  "location": "Washington",
  "maxItems": 20,
  "proxy": { "useApifyProxy": true }
}
```

### Example Output JSON

```json
{
  "jobId": "5471053-0",
  "jobTitle": "Police Commander",
  "agency": "City of Lake Forest Park",
  "location": "17425 Ballinger Way N.E., Lake Forest Park, WA",
  "salaryRange": "$117,231.24 - $167,724.84 Annually",
  "closingDate": null,
  "jobType": "Full-Time",
  "fullDescription": "<p style=\"margin: 10px 0; ...\">...",
  "descriptionText": "The City of Lake Forest Park is recruiting for the position of Police Commander ...",
  "applicationUrl": "https://www.governmentjobs.com/jobs/5471053-0/police-commander/apply",
  "url": "https://www.governmentjobs.com/jobs/5471053-0/police-commander",
  "jobNumber": "PD-2604",
  "department": "Police",
  "openingDate": "09/02/2026",
  "datePosted": "2026-09-02",
  "employmentType": "FULL_TIME",
  "salaryMin": 117231.24,
  "salaryMax": 167724.84,
  "salaryCurrency": "USD",
  "salaryUnit": "YEAR",
  "featured": false,
  "closingInfo": null
}
```

### Integrations & Scheduling

Because this is an Apify Actor, you can plug it into any workflow:

- **API** — run it from code: `POST /v2/acts/ahmed_jasarevic~governmentjobs-scraper/runs` with the input above, then pull the dataset.
- **Schedules** — use the console or the [Schedules API](https://docs.apify.com/api/v2#/reference/schedules/schedule-collection/create-schedule) to run it **daily or weekly** for ongoing public-sector job monitoring (e.g. every Monday morning to track new openings).
- **No-code** — Zapier, Make (Integromat), Google Sheets, Slack and Pipedream integrations built into the Apify console.
- **Pipelines** — combine with other job actors (see Related Actors) to feed one unified job database.

### Related Actors

- [USA Jobs Scraper](https://apify.com/shahidirfan/USA-Jobs-Scraper) — federal USAJOBS listings (titles, agencies, locations, salaries).
- [USAJobs Scraper - Federal Government Jobs Data](https://apify.com/logiover/usajobs-scraper) — scrapes USAJobs.gov without an API key — a practical USAJOBS API alternative for federal data.
- [CareerBuilder Scraper](https://apify.com/ahmed_jasarevic/careerbuilder-scraper) — US private-sector listings with salary ranges for cross-market benchmarking.
- [Snagajob Scraper](https://apify.com/ahmed_jasarevic/snagajob-scraper) — US hourly & part-time jobs and verified wages.
- [Builtin Scraper](https://apify.com/ahmed_jasarevic/builtin-scraper) — US tech/startup jobs with salary ranges and remote flags.

### FAQ

**Is there an official governmentjobs.com API?** No. Unlike federal USAJOBS (which has a free public API via `developer.usajobs.gov`), governmentjobs.com / NEOGOV does not publish an official job-data API. This actor fills that gap by extracting the same public listings and their embedded JSON-LD `JobPosting` data — the standard approach for GovernmentJobs (NEOGOV) data extraction.

**How does this differ from USAJOBS?** USAJOBS covers **federal** positions; governmentjobs.com covers the **state, county, municipal, school district and transit** market — most local government jobs are not on USAJOBS. If you want both, run this actor alongside a USAJOBS scraper. Against general boards (Indeed, LinkedIn), governmentjobs.com is the only board where cities and counties consistently post with salary ranges and a single standardized application URL.

**Is scraping "how to scrape government jobs" data legal?** The actor reads **publicly available job postings** — job titles, agencies, salaries, descriptions and application URLs. It does not collect any applicant, personal or account data. You are responsible for complying with the target site's terms of service and applicable law in your jurisdiction; see the Legal & Compliance Disclaimer below.

**Why is some data empty?** Many government postings are continuous-recruitment ads with no closing date (`closingDate: null`), and some omit a salary range. Those fields are returned as `null` — the available fields are always populated.

**What does it cost to run?** Pay-per-event: **$0.005 per job result** plus a tiny Actor-start charge (~$0.00005 per GB). A 50-job run costs about $0.25. Free Apify accounts see a 10-job preview; paid accounts scrape up to your `maxItems`.

### SEO Keywords

government jobs, government jobs scraper, public sector jobs, government jobs data, government jobs database, scrape government jobs, government jobs api, city government jobs, state government jobs, county jobs, municipal jobs, public sector job listings, government salary data, government salary ranges, public sector salaries, usajobs alternative, neogov jobs, government hiring trends, public administration jobs, police jobs, federal jobs listings, government job board

### For AI Agents & LLM Apps

This actor is an ideal tool for AI agents and LLM applications that need fresh, structured US public-sector job data.

- **Purpose** — return a clean, flat JSON array of current US state/local government job postings with structured salary data, ideal for RAG, job-search chatbots, workforce analytics and salary-benchmarking assistants.
- **Minimal input** — `{ "maxItems": 50 }` is enough; add `keyword`, `location`, `category` or `organization` to scope the query. Optionally include `"proxy": { "useApifyProxy": true }`.
- **Output fields your LLM can rely on** — `jobTitle`, `agency`, `location`, `salaryRange`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryUnit`, `closingDate`, `jobType`, `employmentType`, `department`, `datePosted`, `descriptionText`, `applicationUrl`, `url`.
- **Recommended behaviours when calling from an agent**:
  - **Always set `maxItems`** — the actor is pay-per-event at **$0.005 per result**, and `maxItems` is the only cap on billable results. E.g. `maxItems: 100` ≈ $0.50. Never call it without a cap.
  - Set sensible defaults: `maxItems: 50`, and add `keyword`/`location` filters to keep runs small and targeted.
  - Use `applicationUrl` for "where to apply" answers; use `descriptionText` (not `fullDescription` HTML) when passing description text to an LLM to save tokens.
  - For time-series questions ("how many police jobs opened this month?"), schedule the actor and rely on `datePosted` — don't re-scrape the full board per question.
- **Billing model** — Pay-per-event (PPE): **$0.005 per dataset result** (primary event) + Actor-start fee (~$0.00005 per GB of memory). There is no subscription; you only pay for what you scrape, capped by `maxItems`.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by NEOGOV or GovernmentJobs.com**. "GovernmentJobs" and "NEOGOV" are trademarks of their respective owners and are referenced only to describe the publicly available source.

The actor collects only **publicly posted job information** (job title, agency, location, salary, description, application URL, dates). It does **not** collect applicant data, resumes, accounts, or any personal information of job candidates, because job postings do not contain such data.

By using this Actor you agree that: (1) you are responsible for reviewing and complying with the target website's Terms of Service, robots.txt, rate limits and any applicable laws in your jurisdiction; (2) the actor is provided "as-is" without warranties and is intended for legitimate purposes such as research, analytics and job aggregation; (3) you will not use scraped data to harm the source site, to publish misleading job listings, or for any unlawful purpose. Public-sector job information collected from official sources is public data; however, end-user responsibility for lawful use remains with the user. For questions, open an issue in the Actor's Issues tab.

# Actor input Schema

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

Search keyword to filter jobs by title (e.g. "police", "nurse", "engineer"). Leave empty to browse all jobs.

## `location` (type: `string`):

Location filter (e.g. "Seattle, WA", "Texas"). Leave empty for all locations.

## `category` (type: `string`):

Job category filter (e.g. "Public Safety"). Leave empty for all categories.

## `organization` (type: `string`):

Organization / agency filter (e.g. "City of Seattle"). Leave empty for all organizations.

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

Maximum number of job detail pages to scrape. The actor keeps crawling search result pages (up to 10 jobs each) until this limit is reached.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "maxItems": 50,
  "proxy": {
    "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 = {
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/governmentjobs-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 = { "proxy": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/governmentjobs-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 '{
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call ahmed_jasarevic/governmentjobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/governmentjobs-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/37TRZiCGqly9LIEuU/builds/JMWfuvvhcDjsApvp8/openapi.json