# USAJOBS Federal Jobs Feed: US Government Job Alerts (`fedsignals/usajobs-federal-jobs-feed`) Actor

New US federal government jobs from the official USAJOBS API with your own free key. Filter by keyword, location, remote, GS grade, salary, clearance and hiring path. Scheduled runs return only new jobs, with salary in USD, closing date and the official announcement link. No contact names.

- **URL**: https://apify.com/fedsignals/usajobs-federal-jobs-feed.md
- **Developed by:** [FedSignals Data](https://apify.com/fedsignals) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 federal job rows

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

## USAJOBS Federal Jobs Feed: US Government Job Alerts

Get **new US federal government jobs** from USAJOBS as clean JSON rows: title, agency, GS grade, salary in USD, duty locations, remote and telework, clearance, who may apply, open and close dates, and the link to the official announcement. Filter by **keyword, location, remote, GS grade, salary, security clearance and hiring path**. Schedule it daily and it returns **only jobs you haven't seen yet**. It uses the official USAJOBS Search API with **your own free USAJOBS API key**, so there is no scraping and no login.

**US federal jobs only:** this covers US federal government jobs listed on USAJOBS (including federal posts overseas), not state, local or private-sector jobs.

Built and maintained by **FedSignals Data**.

### What it does

- **Searches USAJOBS announcements posted in your time window** (often more than 1,000 new federal jobs on a weekday) through the official Search API, newest first. Keyword, location, remote, GS grade and hiring-path filters are applied by USAJOBS itself. USAJOBS returns at most 10,000 jobs per search (newest first), and clearance and salary are checked after download, so a clearance or salary filter with no keywords or locations over a long window (for example L access over 60 days) checks only the newest 10,000 jobs; add a keyword or location, or a shorter `postedWithinDays`, to cover the whole window.
- **Filters** by keywords, duty locations (city, state or 2-letter state code), fully remote jobs, GS grade range, minimum salary, security clearance and hiring path (open to the public, veterans, students, recent graduates, military spouses and more).
- **Clean fields**: grade like `GS-12/13`, salary range with `currency: "USD"` and the pay interval, ISO dates, `daysUntilClose` and a `closingSoon` flag for jobs that close within 7 days.
- **New-only across runs**: `onlyNew` remembers which jobs it already delivered for your filter set, so a daily schedule returns, and charges for, new jobs only. Keep `onlyNew` on when you schedule it (the Console example turns it off so you can see results right away).
- **No contact names**: agency contact names, emails and phone numbers are never output. Each row links to the official announcement, where the contact and application instructions are.

### Before you start: get your free USAJOBS API key

1. Fill in the free request form at https://developer.usajobs.gov/APIRequest/Index.
2. Open the verification link USAJOBS emails you.
3. USAJOBS then emails you your API key.
4. Paste the key into `usajobsApiKey` and the email you registered with into `usajobsEmail`.

The key is a secret input: Apify stores it encrypted, and the Actor sends it only to USAJOBS. It is never logged or written to the dataset. If the key or email is missing, Apify refuses to start the run (error: `Field input.usajobsApiKey is required`) and nothing is charged. If the key is blank, malformed or rejected by USAJOBS, the run stops before any job is charged, with a message saying what to fix.

### Use cases

- Daily "new federal jobs for me" alerts by email, Slack or Google Sheets (e.g. GS-12 to GS-14 data jobs in Colorado, or remote cybersecurity jobs with a Secret clearance)
- Career coaches, veteran and military-spouse programs, and university career centers tracking jobs open to their groups
- Federal hiring trends by agency, location, grade and salary
- Feeding a job board, newsletter or AI job-matching agent with fresh, structured federal jobs

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `usajobsApiKey` | secret text | **required** | Your free USAJOBS API key. |
| `usajobsEmail` | text | **required** | The email you registered the key with. |
| `keywords` | text | – | Comma-separated keywords, e.g. `data scientist, nurse`. Each keyword is a separate search; results are merged. Max 10. |
| `locations` | list | anywhere | `Denver, Colorado`, `Virginia`, `VA`, or a country for overseas posts (`Japan`). Max 20. A misspelled state fails before any job is charged, with a suggestion. |
| `remoteOnly` | boolean | false | Only fully remote jobs (telework-eligible is not the same; see `teleworkEligible`). |
| `gradeMin` / `gradeMax` | integer | – | GS grade range, 1–15. Matches jobs whose grade range overlaps yours. |
| `salaryMin` | integer | – | Keep jobs whose pay range reaches at least this yearly amount in USD (compared with the top of the range). Hourly pay is converted at 2,087 hours a year. |
| `securityClearance` | list | any | `notRequired`, `confidential`, `secret`, `topSecret`, `sci`, `qAccess`, `lAccess`, `other`. |
| `hiringPaths` | list | all | Who may apply: `public`, `vet`, `nguard`, `disability`, `native`, `mspouse`, `student`, `graduates`, `ses`, `peace`, `overseas`, `fed-competitive`, `fed-excepted`, `fed-internal-search`, `fed-transition`, `land`, `special-authorities`. |
| `postedWithinDays` | integer | 3 | Only jobs posted in the last N days (1–60). |
| `onlyNew` | boolean | true | Return only jobs not delivered by an earlier run with the same filters. |
| `maxItems` | integer | 100 | Stop after this many jobs (1–10,000; caps the cost). |
| `stateKey` | text | – | Advanced: name the "already seen" memory to share it between tasks. |

### Example input

```json
{
  "usajobsApiKey": "YOUR-USAJOBS-KEY",
  "usajobsEmail": "you@example.com",
  "keywords": "analyst",
  "postedWithinDays": 3,
  "onlyNew": false,
  "maxItems": 10
}
```

A daily alert for Colorado data jobs at GS-12 and up, open to the public:

```json
{
  "usajobsApiKey": "YOUR-USAJOBS-KEY",
  "usajobsEmail": "you@example.com",
  "keywords": "data scientist, data analyst, statistician",
  "locations": ["Colorado"],
  "gradeMin": 12,
  "hiringPaths": ["public"],
  "postedWithinDays": 3,
  "onlyNew": true
}
```

### Output

One row per job, newest first. This row is copied unchanged from a real run (run `wXcvCCOyR4sQ9dgwk`, keyword `data scientist`, Nov 3, 2026):

```json
{
  "jobId": "891403000",
  "announcementNumber": "CBSR-13107264-27-CP",
  "title": "Clinical Laboratory Scientist (Laboratory Information Manager)",
  "agency": "Veterans Health Administration",
  "subAgency": "Battle Creek VA Medical Center",
  "department": "Department of Veterans Affairs",
  "locations": [
    "Wyoming, Michigan"
  ],
  "countries": [
    "United States"
  ],
  "remote": false,
  "teleworkEligible": false,
  "payPlan": "GS",
  "grade": "GS-12",
  "gradeLow": 12,
  "gradeHigh": 12,
  "salaryMin": 109189,
  "salaryMax": 141949,
  "salaryInterval": "year",
  "currency": "USD",
  "schedule": "Full-time",
  "appointmentType": "Permanent",
  "hiringPaths": [
    "Internal to an agency"
  ],
  "seriesCodes": [
    "0644"
  ],
  "seriesNames": [
    "Clinical Laboratory Science"
  ],
  "clearance": "Not Required",
  "totalOpenings": "1",
  "openDate": "2026-11-03",
  "closeDate": "2026-11-09",
  "closesAt": "2026-11-09T23:59:00-05:00",
  "daysUntilClose": 6,
  "closingSoon": true,
  "url": "https://www.usajobs.gov/job/891403000",
  "source": "USAJOBS (data.usajobs.gov Search API)",
  "scrapedAt": "2026-11-03T17:30:40Z"
}
```

Apply via the official announcement (`url`). This Actor does not submit applications and nothing is sent to USAJOBS or the hiring agency on your behalf.

A **SUMMARY** record in the run's key-value store shows your filters, total matches per search, jobs delivered per department and state, how many close within 7 days, skipped jobs (already seen, other pay plan or grade, other clearance, below salaryMin, not remote) and why the run stopped (`completed`, `maxItems`, `spendingLimit`, `scanLimit`, `upstreamError`). If USAJOBS fails partway through, the run keeps the jobs it already delivered and lists the error under `partialFailures` instead of crashing.

### Pricing

Pay per result: **$0.001 per job** ($1 per 1,000), plus Apify's start fee of $0.00005 per run. Already-seen and filtered-out jobs are skipped for free. Example: a daily run returning 25 new jobs costs about $0.025 per day, or about $0.75 a month. Set `maxItems` or a maximum charge per run to cap the cost; the run stops cleanly before going over it (start fee included). Runs that find nothing new cost only the start fee. If the input or the key is invalid, the run stops before any job is charged; only the start fee applies.

### FAQ

**Why do I need my own API key?** USAJOBS gives every user a free key, and its [API terms](https://developer.usajobs.gov/APIRequest/Index) (section 4) don't allow sharing or transferring API credentials, so one key can't be shared between users. With your own key, your requests are yours and nobody else's usage can affect your runs.

**My run failed with "USAJOBS rejected the API key".** Check that the key is the one USAJOBS emailed you and that `usajobsEmail` is the exact email you registered it with. No job is charged.

**I got `Field input.usajobsApiKey is required` (or `usajobsEmail`).** You started the run (usually through the API or an integration) without the key or email. Add both and run again. Nothing was charged.

**What is the difference between `remote` and `teleworkEligible`?** Remote jobs are worked entirely away from an agency site. Telework-eligible jobs have a duty station but allow some days at home.

**Why did my run return no jobs?** The status message says why: nothing new since the last run (with `onlyNew`), every match filtered out by grade, clearance or salary, or no matches at all. Try more `postedWithinDays` or fewer filters. The `SUMMARY` record shows the totals for each search.

**Does it include the full job description?** No. Announcement bodies often name contact people, so the dataset keeps the structured fields only. The full announcement is at `url`.

**Is this an official USAJOBS or OPM product?** No. It is an independent tool that reads public data from the USAJOBS API.

### Dates, time zones and currency

- `openDate` and `closeDate` are calendar dates (YYYY-MM-DD) as USAJOBS publishes them. Announcements usually close at **11:59 PM US Eastern Time** on `closeDate`; check the announcement, since some close early when they reach an application limit.
- `daysUntilClose` and `closingSoon` (closes within 7 days) are counted from today's date in US Eastern Time; `closesAt` is the usual 11:59 PM ET deadline with its UTC offset (e.g. `2026-11-06T23:59:00-05:00`).
- `postedWithinDays` follows USAJOBS's own "date posted" filter.
- `scrapedAt` is the retrieval date and time, in UTC (ISO 8601).
- All salaries are in **US dollars** (`currency: "USD"`), per `salaryInterval` (usually `year`, sometimes `hour`).

### Other languages and regions

US federal government jobs only, including federal positions in US territories and overseas (for example at bases in Japan or Germany). USAJOBS announcements are in English.

Also searched as: empleos del gobierno federal de EE. UU. (ES) · vagas no governo federal dos EUA (PT) · emplois du gouvernement fédéral américain (FR) · Stellen bei der US-Bundesregierung (DE).

### Limits

- You need your own free USAJOBS API key (see above).
- USAJOBS returns up to 10,000 jobs per search; `postedWithinDays` goes back 60 days.
- Grade (General Schedule pay plans and grade range), remote, location, keyword and hiring path are filtered by USAJOBS. Clearance, salary and the exact grade overlap are checked after download: USAJOBS documents a clearance filter, but in our tests (Nov 3, 2026) the API ignored it. A clearance or salary filter on a broad search over a long window therefore checks only the newest 10,000 jobs; if a search hits that limit, SUMMARY says so (`scanLimit`).
- Setting a GS grade keeps only General Schedule jobs (pay plans GS, GL, GG and GM) and leaves out wage-grade, Senior Executive Service and other pay plans.
- Data is as published by the hiring agencies on USAJOBS; changes appear in later runs.

### Source and terms

Source: USAJOBS (https://www.usajobs.gov), through the USAJOBS Search API (https://developer.usajobs.gov). Every row links to the current official job announcement (`url`) and carries its retrieval date (`scrapedAt`). Fields are renamed and reformatted; contact details and announcement text are omitted. This product is not operated, sponsored, approved, or endorsed by OPM or USAJOBS. Apply via the official announcement on USAJOBS.

### Support

Questions or feature requests: open an issue on the Actor's Issues tab or email fedsignals.alerts@gmail.com.

# Actor input Schema

## `usajobsApiKey` (type: `string`):

Your own free USAJOBS API key. Request one free at https://developer.usajobs.gov/APIRequest/Index (confirm the verification email; the key is emailed to you). It is sent only to USAJOBS, stored encrypted by Apify and never logged or output. Required: without it Apify won't start the run (nothing is charged). A rejected key stops the run before any job is charged.

## `usajobsEmail` (type: `string`):

The email address you registered the key with. USAJOBS requires it with every request (as the User-Agent).

## `keywords` (type: `string`):

Comma-separated keywords searched in the job announcement (e.g. data scientist, nurse, cybersecurity). Each keyword is a separate search; results are merged. Max 10. Empty = all jobs.

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

Duty locations: 'City, State' (Denver, Colorado), a state name (Virginia), a 2-letter state code (VA) or a country for overseas posts (Japan). Max 20. Empty = anywhere. A misspelled state name fails the run before any job is charged, with a suggestion.

## `remoteOnly` (type: `boolean`):

Only jobs USAJOBS marks as fully remote. Telework-eligible jobs are not the same; see the teleworkEligible output field.

## `gradeMin` (type: `integer`):

Lowest General Schedule (GS) grade, 1-15. Matches jobs whose grade range overlaps your range. Setting a grade keeps only General Schedule jobs (GS, GL, GG, GM) and leaves out wage-grade, SES and other pay plans.

## `gradeMax` (type: `integer`):

Highest GS grade, 1-15. Must not be lower than the minimum.

## `salaryMin` (type: `integer`):

Keep jobs whose top of pay range is at least this many US dollars a year. Hourly pay is converted at 2,087 hours a year. Unpaid jobs and jobs without a listed salary are left out when this is set.

## `securityClearance` (type: `array`):

Only jobs requiring one of these clearances. Empty = any. Checked after download (USAJOBS does not filter clearance itself), so with no keywords or locations over many days only the newest 10,000 jobs are checked.

## `hiringPaths` (type: `array`):

Only jobs open to at least one of these groups. Choose 'The public' for jobs any US citizen can apply to. Empty = all.

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

Only jobs posted in the last N days (1-60). For a daily schedule, 3 gives a safe overlap; onlyNew removes the repeats.

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

Return only jobs not delivered by an earlier run with the same filters (or the same state key), so you are never charged twice for the same job. Turn off to get every match each run.

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

Stop after this many jobs (1-10,000). Each delivered job is one charged event.

## `stateKey` (type: `string`):

Optional name for the onlyNew memory. Use the same key in several tasks to share it, or a new key to start fresh. Empty = derived from your filters.

## Actor input object example

```json
{
  "keywords": "analyst",
  "locations": [],
  "remoteOnly": false,
  "postedWithinDays": 3,
  "onlyNew": false,
  "maxItems": 10
}
```

# Actor output Schema

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

New USAJOBS job announcements. One job per row; field definitions are in the dataset schema.

## `summary` (type: `string`):

JSON summary of the run: filters, matches per search, jobs delivered per department and state, skipped jobs and why the run stopped.

# 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",
    "locations": [],
    "postedWithinDays": 3,
    "onlyNew": false,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("fedsignals/usajobs-federal-jobs-feed").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",
    "locations": [],
    "postedWithinDays": 3,
    "onlyNew": False,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("fedsignals/usajobs-federal-jobs-feed").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",
  "locations": [],
  "postedWithinDays": 3,
  "onlyNew": false,
  "maxItems": 10
}' |
apify call fedsignals/usajobs-federal-jobs-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fedsignals/usajobs-federal-jobs-feed"
        }
    }
}
```

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/pXcv2OVTtdBMjy4dl/builds/mzkjP50ORNsdDe5Zu/openapi.json
