# Government Jobs Scraper for GovernmentJobs.com (unofficial) (`civicfeeds/governmentjobs-scraper`) Actor

Extract public sector job listings from GovernmentJobs.com (NEOGOV) by keyword, location, category or agency. Structured salary, dates and full descriptions. Export JSON, CSV or Excel. Pay per result. Unofficial; not affiliated with or endorsed by NEOGOV or GovernmentJobs.com.

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

## Pricing

from $4.00 / 1,000 job 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/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.com Scraper (NEOGOV) - Government Jobs API

> **Unofficial tool.** This actor is not affiliated with, endorsed by, or
> sponsored by NEOGOV or GovernmentJobs.com. It is an independent tool that
> extracts publicly available job listings from governmentjobs.com.

Turn **GovernmentJobs.com** (NEOGOV), the dominant US public sector job platform used by
thousands of city, county and state agencies, into a clean, structured **government jobs API**.
Search by keyword, location, category or agency and get back ready-to-use **NEOGOV jobs data**:
job title, agency, location, structured salary range, job type, posted and closing dates, and
the full job description.

No login, no API keys, no HTML parsing on your side. Just a **public sector jobs feed** in JSON,
CSV or Excel, at roughly **$0.004 per job**: you pay only for the results you actually receive.

### Why use this GovernmentJobs.com scraper

- **Coverage that matters.** GovernmentJobs.com hosts postings from thousands of US government
  employers: cities, counties, states, transit districts, utilities, universities.
- **Structured salary data.** Salary strings like `$7,938.11 - $9,648.82 Monthly` are parsed
  into `salaryMin`, `salaryMax` and a normalized `salaryPeriod` (`YEAR`, `MONTH`, `HOUR`).
- **Full descriptions on demand.** A single toggle adds the complete job description
  (plain text and HTML), department, division, and posted/closing dates from each job's detail
  page. Leave it off for the fastest, cheapest runs.
- **Pay per result.** One charge per job returned. A run that finds 50 jobs costs about 20 cents.
- **Polite by design.** Low default concurrency and a configurable requests-per-minute throttle.

### Use cases

- **Job boards and aggregators**: syndicate public sector openings into your own site or app.
- **Labor market research**: track government hiring volume, salary bands and closing windows
  by region, category or agency over time.
- **Job alerts**: run daily with `postedWithinDays: 1` and push new matches to email, Slack or
  a spreadsheet via Apify integrations.
- **Recruiting and career services**: monitor openings for specific agencies or job families
  (law enforcement, public works, IT, nursing, skilled trades).
- **AI agents and LLM pipelines**: every Apify Actor doubles as an MCP tool; feed structured
  government job data straight into your agent workflows.

### How to scrape government jobs from GovernmentJobs.com

1. Create a free Apify account (no credit card needed).
2. Open the Actor page and click **Try for free**.
3. Enter a `keyword` (e.g. `civil engineer`) and optionally a `location`,
   `category` or `agency`, then click **Start**.
4. When the run finishes, open the **Dataset** tab and export your government
   job listings as JSON, CSV, Excel, XML or RSS.
5. Optional: add a **Schedule** (daily with `postedWithinDays: "1"`) to turn
   one search into a continuously updated public sector job alert feed.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `keyword` | string | Search keyword, e.g. `mechanic`, `civil engineer`. |
| `location` | string | City, state or region, e.g. `California`, `Austin, TX`. |
| `category` | string | Exact site category, e.g. `Automotive`, `Law Enforcement`. Optional. |
| `agency` | string | Exact employer name, e.g. `City of Livermore`. Optional. |
| `postedWithinDays` | string | `1`, `7` or `30` to only return recent postings. Optional. |
| `maxResults` | integer | Cap on returned jobs (default 100). |
| `fetchDescriptions` | boolean | Also fetch each job's detail page for the full description, dates and department (one extra request per job). Default `false`. |
| `maxRequestsPerMinute` | integer | Politeness throttle (default 60). |
| `proxyConfiguration` | object | Proxy settings. Defaults to Apify Proxy (automatic datacenter group). If you see request timeouts, switch to the `RESIDENTIAL` proxy group. |

Example input:

```json
{
    "keyword": "mechanic",
    "location": "California",
    "maxResults": 100,
    "postedWithinDays": "7",
    "fetchDescriptions": true,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

### Output

One dataset item per job. Example (trimmed):

```json
{
    "id": "5016895-0",
    "title": "Bus Mechanic",
    "agency": "Golden Gate Bridge, Highway and Transportation District",
    "location": "San Rafael, CA",
    "state": "CA",
    "postalCode": "94901",
    "jobType": "Regular, Full-Time",
    "salaryText": "$122,636.80 Annually",
    "salaryMin": 122636.8,
    "salaryMax": 122636.8,
    "salaryPeriod": "YEAR",
    "category": null,
    "department": "Bus Maintenance - Mechanics/Stores",
    "division": "Bus Division",
    "postedDate": "2025-12-30",
    "closingDate": "Continuous",
    "employmentType": "OTHER",
    "url": "https://www.governmentjobs.com/jobs/5016895-0/bus-mechanic",
    "isFeatured": true,
    "description": "Under supervision, performs inspection, maintenance, troubleshooting...",
    "descriptionHtml": "<p><strong>...</strong></p>",
    "scrapedAt": "2026-09-28T23:59:00.000Z"
}
```

Without `fetchDescriptions`, each item still includes id, title, agency, location, job type,
parsed salary range and the job URL; `description`, dates and department are only populated
when detail fetching is enabled.

Notes:

- `closingDate` may be a date (`2026-10-20`) or the literal `Continuous` for open-until-filled
  postings; some agencies omit it entirely.
- `category` echoes your category filter; GovernmentJobs.com does not display a category on
  individual job pages.
- `description` is plain text; `descriptionHtml` preserves the agency's original formatting.

### How much does it cost to scrape GovernmentJobs.com?

Pay per event: about **$0.004 per job returned**, and nothing for empty searches. Typical runs:

| Run | Approximate cost |
| --- | --- |
| 100 jobs, listings only | $0.40 |
| 100 jobs with full descriptions | $0.40 plus a little compute |
| Daily alert, ~10 new jobs/day, 30 days | ~$1.20/month |

### Government jobs API: integrate with code or AI agents (MCP)

Call this Actor from any language with the Apify API and use it as a drop-in
**government jobs API**.

JavaScript (apify-client):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('civicfeeds/governmentjobs-scraper').call({
    keyword: 'civil engineer',
    location: 'Texas',
    maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python (apify-client):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("civicfeeds/governmentjobs-scraper").call(run_input={
    "keyword": "civil engineer",
    "location": "Texas",
    "maxResults": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["agency"], item["salaryText"])
```

**MCP for AI agents.** Every Apify Actor is also an MCP (Model Context
Protocol) tool. Point your agent (Claude, Cursor, or any MCP client) at
`https://mcp.apify.com` with your Apify token and it can search government
jobs on demand inside your agent workflows.

Apify integrations also connect runs to **Google Sheets, Make, Zapier,
Slack and webhooks**, and Schedules let you run the scraper hourly, daily or
weekly without writing any code.

### Compliance

This Actor only accesses publicly available job listings that GovernmentJobs.com serves to any
visitor without a login. It collects no personal data, respects a conservative request rate, and
is intended for legitimate uses such as job aggregation, research and alerts. It is not intended
for, and must not be used for, consumer screening or any purpose governed by the FCRA.

**Copyright warning on job descriptions.** Job description prose written by state and local
agencies MAY be copyrighted: unlike federal works, state and local government text is not
automatically in the public domain. Structured facts (title, agency, salary, dates) are fine;
use the description text for analysis, aggregation and alerts, not for verbatim republication.
Obtain rights from the posting agency before republishing description text.

**GDPR.** If you collect any personal data with this tool, you, the end user, are the data
controller for that data. EU users are responsible for establishing their own lawful basis for
any processing of personal data.

**Operating rule.** This Actor respects targeted revocation. If the target site issues a
cease-and-desist or otherwise individually revokes access, access folds: the Actor will be
paused and reassessed immediately.

### FAQ

**Is there an official GovernmentJobs.com API?** NEOGOV does not offer a public API for job
search. This Actor fills that gap by extracting the same listings any visitor can see, delivered
as structured data.

**Is it legal to scrape GovernmentJobs.com?** This Actor only collects job listings that are
publicly visible to any visitor without a login, at a polite request rate, and collects no
personal data. See the Compliance section above for the details, including the FCRA restriction
and the note on job description copyright.

**How fresh is the data?** Every run fetches live listings. Schedule the Actor (hourly, daily,
weekly) to keep a continuously updated public sector jobs feed.

**Can I export to CSV, Excel or Google Sheets?** Yes. Apify datasets export to JSON, CSV, Excel,
XML and RSS, and integrate with Google Sheets, Make, Zapier and webhooks.

# Actor input Schema

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

Search keyword, e.g. <code>mechanic</code>, <code>civil engineer</code>, <code>police officer</code>. Leave empty to match all jobs for the other filters.

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

City, state or region as you would type it into the site's location box, e.g. <code>California</code>, <code>Austin, TX</code>, <code>King County, WA</code>.

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

Exact job category as shown in the site's Category filter, e.g. <code>Automotive</code>, <code>Public Works</code>, <code>Law Enforcement</code>. Optional.

## `agency` (type: `string`):

Exact employer name as shown in the site's Employer filter, e.g. <code>City of Livermore</code>. Optional.

## `postedWithinDays` (type: `string`):

Only return jobs posted within the last N days.

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

Maximum number of job listings to return. You are only charged per result actually returned.

## `fetchDescriptions` (type: `boolean`):

Also open each job's detail page to capture the full description text, posted/closing dates, department and structured salary. One extra request per job; leave off for the cheapest, fastest runs.

## `maxRequestsPerMinute` (type: `integer`):

Politeness throttle. Lower this if you want to be extra gentle with the site.

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

Proxy to use for requests. Apify Proxy (automatic datacenter) is the default. If you see request timeouts, switch to the <code>RESIDENTIAL</code> proxy group.

## Actor input object example

```json
{
  "keyword": "mechanic",
  "location": "California",
  "postedWithinDays": "",
  "maxResults": 100,
  "fetchDescriptions": false,
  "maxRequestsPerMinute": 60,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keyword": "mechanic",
    "location": "California",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("civicfeeds/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 = {
    "keyword": "mechanic",
    "location": "California",
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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