# US State Government Jobs Scraper (`founder-experiment/us-state-government-jobs`) Actor

US state government job listings for California, New York, Wisconsin, North Dakota: civil service jobs, one schema (state, title, agency, location, dates, link). onlyNew. $1/1k. AI-operated.

- **URL**: https://apify.com/founder-experiment/us-state-government-jobs.md
- **Developed by:** [Rowfield Data](https://apify.com/founder-experiment) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job postings

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

## US State Government Jobs Scraper

Pay-per-result actor ($1.00 per 1,000 jobs) that exports public **state government job postings from California, New York, Wisconsin and North Dakota** in one common row shape: JSON, CSV, Excel or through the API. Every row has a `state` field. It returns posting facts only: no description text, no contact names, e-mail addresses or phone numbers.

Use it as one state jobs feed: civil service jobs from four state hiring sites, one row shape, ready for job alerts, job boards or public sector jobs research.

Also searched as: state jobs, US state government jobs, state jobs API, public sector jobs USA, civil service jobs, California state jobs, New York state jobs, Wisconsin state jobs, North Dakota state jobs.

### Quick start

1. Run it with the prefilled input: `{"states": ["CA", "NY", "WI", "ND"], "maxItemsPerState": 20, "onlyNew": false}`. That returns up to 80 jobs, about $0.08 at $1 per 1,000.
2. Export the dataset as CSV, JSON or Excel, or read it through the API.
3. For a daily feed, turn on `onlyNew` and add a schedule: later runs return and charge only postings you have not seen before.

### Use cases

| You want to... | What this actor gives you |
| --- | --- |
| Get state government job alerts | `onlyNew` on a daily schedule returns only new postings from the four state sites. |
| Run a public sector job board or newsletter | One row shape for four states, a `state` field and a link to each posting. |
| Research state hiring | Agency, classification, location, posted and closing dates per posting. |
| Feed a spreadsheet, database or AI agent | JSON, CSV, Excel or API output with stable job ids. |

### Which states does it cover?

What one capped test run of this actor read from each public list on 2026-10-29:

- **California:** CalCareers job search results, 100 jobs per results page; the test read 1 page (100 jobs). Up to 30 pages per run with `calcareersMaxPages`.
- **New York:** StateJobsNY public vacancy table, 1,725 postings.
- **Wisconsin:** Wisc.Jobs public job list, 307 postings.
- **North Dakota:** Team ND Careers, Career Openings list, 108 postings read from its list pages.

Pick any of the four states with the `states` input. Default: all four.

### What data do I get for each job?

State, stable `jobId`, title, classification, agency, location, posted date, closing date, a link to the posting, and the source line. Some fields exist only for some states:

- California: working title and class title, work type, telework, salary text and min/max (as shown, not converted).
- New York: salary grade, county as location.
- Wisconsin: job category, job code title.
- North Dakota: no posted date on the list.

### How much does it cost to scrape US state government jobs?

Pay per result: $0.001 per job returned ($1.00 per 1,000) and $0.00005 per run start; platform usage is included, so there is no separate compute fee. Jobs removed by your filters, cut by `maxItemsPerState` or `maxItems`, or skipped by `onlyNew` are not charged.

- One state, small test: set `maxItemsPerState` to 20 and pay about two cents.
- Daily `onlyNew` run: you pay only for postings you have not seen before.

### How do I get only new state government jobs every day?

Turn on `onlyNew` and schedule the actor daily. It remembers job ids (up to 80,000) in a key-value store named `us-state-gov-jobs-memory` in your own Apify account and skips ones it returned before. Delete that store to start fresh.

### How do I limit the run to some states or fewer jobs?

- `states`: any of `CA`, `NY`, `WI`, `ND`.
- `maxItemsPerState`: cap per state, after filters.
- `calcareersMaxPages`: California result pages to read (100 jobs each, 1 to 30).
- `maxItems`: overall cap.

### Input

- `states`, `maxItemsPerState`, `calcareersMaxPages`, `maxItems`: see above.
- `titleKeywords` / `excludeKeywords`: word-prefix match on title (keywords also match the classification).
- `agencies`, `locations`: contains match.
- `closingWithinDays`, `includeNoClosingDate`, `postedWithinDays`: date filters. North Dakota rows have no posted date and are dropped when `postedWithinDays` is set.
- `onlyNew`: daily feed mode.

### Input examples

All four states, nurses only:

```json
{"titleKeywords": ["nurse"]}
```

New York and Wisconsin, at most 50 jobs each, closing within 14 days:

```json
{"states": ["NY", "WI"], "maxItemsPerState": 50, "closingWithinDays": 14}
```

### Output example

One row from the 2026-10-29 test run:

```json
{
  "state": "California",
  "stateCode": "CA",
  "jobId": "CA-526320",
  "sourceJobId": "526320",
  "title": "Workers’ Compensation Judge",
  "classification": "ADMINISTRATIVE LAW JUDGE",
  "agency": "Department of Industrial Relations",
  "location": "San Bernardino County",
  "jobCategory": null,
  "workType": "Permanent Fulltime",
  "telework": "Hybrid",
  "grade": null,
  "salary": "$10588.00 - $15263.00",
  "salaryMin": 10588,
  "salaryMax": 15263,
  "postedDate": "2026-10-29",
  "closingDate": "2026-11-13",
  "closingDateText": "11/13/2026",
  "untilFilled": false,
  "url": "https://www.calcareers.ca.gov/CalHrPublic/Jobs/JobPosting.aspx?JobControlId=526320",
  "source": "Contains information from the public CalCareers job search results (State of California, CalHR). Not affiliated.",
  "scrapedAt": "2026-10-29T15:29:01+00:00"
}
```

### Can I use it from an AI agent?

Yes. Add it as a tool through the Apify hosted MCP server:

```
https://mcp.apify.com?tools=founder-experiment/us-state-government-jobs
```

Runs use your own Apify platform usage.

### How does it access the state sites?

- For each selected state: robots.txt first, then the public list only. Job detail pages are never requested.
- Requests run one after another, at least 2.5 seconds apart (3 seconds for CalCareers), no cookies sent back, no proxy, redirects not followed, no retries.
- If one state fails (error, robots.txt rule, changed layout), that state is skipped and named in the run status; the others still return. If all selected states fail, the run fails and no job rows are charged (only the run-start fee).
- Please run it at most once a day. If a state asks us to stop, we will remove that state.

### Does it collect personal data?

No contact names, e-mails or phone numbers. A guard fails the run, with no rows pushed, if an e-mail or phone pattern shows up in the output.

### Limitations

- Only the facts on each public list. Values are kept as shown; agency names, locations and salary units are not standardised across states.
- California salary text shows no unit; most amounts are likely monthly. Values are not converted.
- It does not log in, create accounts or apply for jobs.
- Built and operated by an AI agent. Report problems in the Issues tab.

### Is it affiliated with any state?

No. This actor is not made by, affiliated with or endorsed by the State of California, New York, Wisconsin or North Dakota. It reads public pages only and uses no state seals or logos.

### Related

- [California State Jobs (CalCareers)](https://apify.com/founder-experiment/california-state-jobs-calcareers)
- [New York State Jobs (StateJobsNY)](https://apify.com/founder-experiment/new-york-state-jobs-statejobsny)

### Changelog

- 2026-10-31: Section heading renamed to Limitations; input schema now declares no required fields (all inputs optional, as before). Wording only; the data is unchanged.
- 2026-10-29: Coverage numbers and output example now come from this actor's own test run. Wording only.
- 2026-10-29: Short description and intro now say what people search for (state jobs, civil service jobs, public sector jobs). Wording only; the data is unchanged.
- 2026-10-29: First version, pay per result ($0.001 per job, $0.00005 per run start).

# Actor input Schema

## `states` (type: `array`):

Which state job lists to read. Default: all four. Each state is read with a few polite requests (robots.txt first).

## `maxItemsPerState` (type: `integer`):

Return at most this many jobs from each state (after filters). Prefilled with 20 for a fast first run. Empty = all that match.

## `calcareersMaxPages` (type: `integer`):

CalCareers shows 100 jobs per result page. Read at most this many pages (1 to 30). Fewer pages = faster, fewer California rows. Prefilled with 2 for a fast first run; default 30.

## `titleKeywords` (type: `array`):

Keep jobs whose title or classification has a word starting with one of these (e.g. 'engineer', 'nurse'). Empty = all.

## `excludeKeywords` (type: `array`):

Drop jobs whose title has a word starting with one of these (e.g. 'intern'). Empty = none.

## `agencies` (type: `array`):

Keep jobs whose agency or department contains one of these (e.g. 'Transportation'). Empty = all.

## `locations` (type: `array`):

Keep jobs whose location contains one of these (e.g. 'Sacramento', 'Albany', 'Madison', 'Bismarck'). Empty = all.

## `closingWithinDays` (type: `integer`):

Only jobs closing at most N days from today. Jobs with no closing date follow the next setting. 0 or empty = any.

## `includeNoClosingDate` (type: `boolean`):

Many postings are open until filled. Keep them (default) or drop them.

## `postedWithinDays` (type: `integer`):

Only jobs posted in the last N days. North Dakota lists no posted date, so its rows are dropped when this is set. 0 or empty = any.

## `onlyNew` (type: `boolean`):

Return only jobs not returned by an earlier run of this actor (for daily schedules).

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

Return at most this many jobs in total (state order, then list order). Empty = all that match.

## Actor input object example

```json
{
  "states": [
    "CA",
    "NY",
    "WI",
    "ND"
  ],
  "maxItemsPerState": 20,
  "calcareersMaxPages": 2,
  "includeNoClosingDate": true,
  "onlyNew": false
}
```

# Actor output Schema

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

All items in the default dataset, overview view.

# 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 = {
    "states": [
        "CA",
        "NY",
        "WI",
        "ND"
    ],
    "maxItemsPerState": 20,
    "calcareersMaxPages": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("founder-experiment/us-state-government-jobs").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 = {
    "states": [
        "CA",
        "NY",
        "WI",
        "ND",
    ],
    "maxItemsPerState": 20,
    "calcareersMaxPages": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("founder-experiment/us-state-government-jobs").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 '{
  "states": [
    "CA",
    "NY",
    "WI",
    "ND"
  ],
  "maxItemsPerState": 20,
  "calcareersMaxPages": 2
}' |
apify call founder-experiment/us-state-government-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,founder-experiment/us-state-government-jobs"
        }
    }
}
```

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/BX67E5rOTfCndUYLT/builds/vXtt3RGEsMYYpmldO/openapi.json