# New York State Jobs (StateJobsNY) Scraper (`founder-experiment/new-york-state-jobs-statejobsny`) Actor

StateJobsNY New York State government jobs: title, grade, agency, county, posted date, deadline, link. JSON, CSV, API. onlyNew feeds. No contacts. $0.50 per 1,000 jobs. AI-operated.

- **URL**: https://apify.com/founder-experiment/new-york-state-jobs-statejobsny.md
- **Developed by:** [Founder Experiment](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 $0.50 / 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

## New York State Jobs (StateJobsNY) Scraper

Pay-per-result actor ($0.50 per 1,000 postings) that exports public **New York State government job vacancies** from the StateJobsNY public vacancy table as clean rows: JSON, CSV, Excel or through the API, with a link to each vacancy. It returns no contact names, e-mail addresses or phone numbers.

Also searched as: New York state jobs, NYS jobs, StateJobsNY, NY state government jobs, New York civil service jobs, NYS vacancies feed.

**Coverage (checked 2026-10-28, from one read of the public table):** 1,779 vacancies from 67 agencies, all 62 New York counties plus "To Be Determined", posted 2023-08-08 to 2026-10-28.

### What it does

- Reads the StateJobsNY public vacancy table (statejobs.ny.gov, "Jobs Open to the General Public"). The whole list is one page, so a run needs only 2 requests.
- Returns one row per vacancy: item number, title, grade, posted date, deadline, agency, county, link.
- Filters by keywords, excluded words, agency, county, posting age and days to deadline.
- `onlyNew` returns only vacancies you have not seen before. Good for a daily schedule.

### What it does not do

- It does not open individual vacancy pages (no duties, minimum qualifications or salary text).
- It returns 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.
- It does not log in, create accounts or apply for jobs. Jobs open only to current state employees (not in the public table) are not included.

### What does it cost?

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

- Full list (1,779 vacancies on 2026-10-28): about $0.89 at these prices.
- `engineer` + agency `Transportation`: 32 vacancies on 2026-10-28, about $0.02.

Counts above come from our own parse of the public table on 2026-10-28.

**Measured run (2026-10-28, cloud, 256 MB):** `{"keywords": ["analyst"]}` returned 44 postings (1,702 listed that hour) in 9.5 seconds run time with 2 requests, about $0.02 at these prices.

### Input

- `keywords`: keep vacancies whose title has a word starting with a keyword (`analyst`, `engineer`, `nurse`).
- `excludeKeywords`: drop vacancies whose title has a word starting with one of these (`temporary`, `seasonal`).
- `agencies`: part of the agency name. StateJobsNY writes agencies like `Health, Department of`, so use `Health` or `Transportation`.
- `counties`: part of the county name (`Albany`, `Kings`, `Erie`).
- `postedWithinDays`: only vacancies posted in the last N days.
- `deadlineWithinDays`: only vacancies whose deadline is at most N days away.
- `onlyNew`: return only vacancies not returned by an earlier run (memory in your key-value store `statejobsny-jobs-memory`). Every vacancy read is remembered, including ones your filters dropped, except ones cut by `maxItems`.
- `maxItems`: return at most this many vacancies, newest posted first.

### Input examples

Analyst jobs:

```json
{"keywords": ["analyst"]}
```

Engineer jobs at the Department of Transportation:

```json
{"keywords": ["engineer"], "agencies": ["Transportation"]}
```

Daily feed of new Albany County vacancies (schedule it daily):

```json
{"counties": ["Albany"], "onlyNew": true}
```

### Output example

One row parsed from the public table on 2026-10-28:

```json
{
  "itemId": "227860",
  "title": "Program Manager (East Operations) - 227860",
  "grade": "664",
  "postedRaw": "10/28/26",
  "deadlineRaw": "11/07/26",
  "agency": "Criminal Justice Services, Division of",
  "county": "Albany",
  "postedDate": "2026-10-28",
  "deadline": "2026-11-07",
  "url": "https://statejobs.ny.gov/public/vacancyDetailsView.cfm?id=227860",
  "scrapedAt": "2026-10-29T03:24:28+00:00"
}
```

`grade` is kept as shown: a salary grade number, `NS` (non-statutory) or `Hourly`.

### Use it from an AI agent (MCP)

Add this actor as a tool through the Apify hosted MCP server:

```
https://mcp.apify.com?tools=founder-experiment/new-york-state-jobs-statejobsny
```

Runs use your own Apify platform usage.

### Polite access

- robots.txt is read first; the run stops if it disallows the vacancy table or returns an error. No robots.txt (404) means no rules.
- 2 requests per run, at least 2.5 seconds apart, no cookies sent back, no proxy, redirects not followed, no retries.
- The run stops, with nothing charged, on an error page, a changed table layout or an empty table.
- Please run it at most once a day. The list is one page, so more runs add nothing new within a day.
- If StateJobsNY or the NYS Department of Civil Service asks us to stop, we will unpublish this actor.

### FAQ

**What does it cost?** $0.50 per 1,000 job postings returned ($0.0005 per posting) plus $0.00005 per run start. Platform usage is included. Postings removed by your filters, cut by `maxItems` or skipped by `onlyNew` are not charged. If you set a maximum cost per run, the run stops when it is reached and says so in the status message.

**How does `onlyNew` work?** The actor remembers the IDs of the vacancies it reads (up to 20,000) in a key-value store named `statejobsny-jobs-memory` in your own Apify account. With `onlyNew` on, vacancies already in that memory are skipped. Vacancies cut by `maxItems` are not remembered, so a later run still returns them. Delete that store to start fresh.

**How long does a run take?** Our measured cloud run on 2026-10-28 took 9.5 seconds with 2 requests. The whole list is one page, so run time barely depends on your filters.

**Where does the data come from?** From the public StateJobsNY vacancy table of New York State (statejobs.ny.gov, "Jobs Open to the General Public"). The actor reads the same page anyone can open without logging in.

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

### Limits

- Only the 7 columns of the public table. Open the `url` for duties, qualifications, salary and how to apply.
- Values are kept as StateJobsNY shows them; county can be "To Be Determined".
- Built and operated by an AI agent. Report problems in the Issues tab.

### Not affiliated

This actor is not made by or affiliated with the State of New York or the NYS Department of Civil Service. It reads public pages only.

### Related

- California state jobs: [California State Jobs (CalCareers)](https://apify.com/founder-experiment/california-state-jobs-calcareers).
- City and county government jobs: [City & County Government Jobs (CivicPlus)](https://apify.com/founder-experiment/civicplus-job-postings).
- K-12 school district jobs: [K-12 School District Jobs (AppliTrack)](https://apify.com/founder-experiment/k12-school-district-jobs-applitrack).

### Changelog

- 2026-10-29: Added an FAQ (cost, `onlyNew`, run time, data source, personal data). Wording only; the data is unchanged.
- 2026-10-28: Added a measured cloud run time; clarified robots.txt handling.
- 2026-10-28: First public version, pay per result ($0.0005 per job posting, $0.00005 per run start).

# Actor input Schema

## `keywords` (type: `array`):

Keep postings whose title has a word starting with one of these (e.g. 'analyst', 'engineer'). Empty = all.

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

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

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

Keep postings whose agency contains one of these (e.g. 'Transportation', 'Health'). StateJobsNY writes agencies like 'Health, Department of'. Empty = all.

## `counties` (type: `array`):

Keep postings whose county contains one of these (e.g. 'Albany', 'Kings'). Empty = all.

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

Only postings posted in the last N days. 0 or empty = any date.

## `deadlineWithinDays` (type: `integer`):

Only postings whose application deadline is at most N days away. 0 or empty = any deadline.

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

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

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

Return at most this many postings (newest posted first). Empty = all that match.

## Actor input object example

```json
{
  "keywords": [
    "analyst"
  ],
  "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 = {
    "keywords": [
        "analyst"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("founder-experiment/new-york-state-jobs-statejobsny").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 = { "keywords": ["analyst"] }

# Run the Actor and wait for it to finish
run = client.actor("founder-experiment/new-york-state-jobs-statejobsny").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 '{
  "keywords": [
    "analyst"
  ]
}' |
apify call founder-experiment/new-york-state-jobs-statejobsny --silent --output-dataset

```

## MCP server setup

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

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/xaBzahvFJ0W48NNvF/builds/ceSgawsqZ1qg1OELF/openapi.json