# USAJobs Federal Jobs Scraper (`logiover/usajobs-scraper`) Actor

Scrape US federal government job announcements from the official USAJobs.gov API — no login, no API key, no blocking. Full hiring details: salary, grade, agency, schedule, clearance, location. Tens of thousands of jobs per run. Schedule it for a fresh federal-jobs feed.

- **URL**: https://apify.com/logiover/usajobs-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 10 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 🇺🇸 USAJobs Scraper — Federal Government Job Listings Data

![USAJobs Federal Jobs Scraper](https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/GjS6nQ8qauOdq9KGy-actor-RenntKrxUtdZQl1jH-ZRY9dL30LM-unnamed.png)

Scrape **US federal government job announcements** straight from the **official USAJobs.gov API** — no login, no API key, no blocking. This Apify Actor pulls the complete USAJobs Historic JOA dataset: every federal job announcement with full hiring details including salary, grade, agency, work schedule, security clearance, telework eligibility, and location. One run can return **tens of thousands of job announcements**.

If you need reliable **USAJobs data** for labor-market research, recruitment intelligence, or a federal-jobs board, this Actor delivers clean, structured output you can export to JSON, CSV, or Excel.

### ✨ What this Actor does / Key features

- **Official government API source** — pulls directly from USAJobs.gov, so it is reliable, never gets blocked, and rarely breaks.
- **No API key or login required** — just set your filters and run.
- **High volume** — full pagination at 500 jobs per page, returning tens of thousands of announcements per run.
- **Rich hiring data** — salary range, pay scale, GS grade, hiring department and agency, work schedule, service type, and appointment type.
- **Filter by date range** — scrape job announcements opened within a specific window.
- **Filter by keyword, department, or occupational series** — narrow to "engineer", "nurse", IT (2210), Veterans Affairs (VA), and more.
- **Detailed eligibility fields** — security clearance, travel requirement, telework eligibility, relocation reimbursement, drug-test requirement, and who-may-apply.
- **Built for scheduling** — run it daily or weekly on a rolling date range for a continuously fresh federal-jobs feed.
- **Structured output** — every announcement includes a direct USAJobs URL and scrape timestamp.

### 🔍 Input

| Field | Type | Description |
|---|---|---|
| `startDate` | string | Earliest position open date (YYYY-MM-DD). Leave empty for the last 30 days. |
| `endDate` | string | Latest position open date (YYYY-MM-DD). Leave empty for today. |
| `keyword` | string | Free-text keyword matched against the position title, e.g. `engineer`, `nurse`, `analyst`. Leave empty for all jobs. |
| `hiringDepartmentCodes` | array | Filter by federal department code, e.g. `AF` (Air Force), `VA` (Veterans Affairs), `TR` (Treasury). Leave empty for all departments. |
| `positionSeries` | array | Filter by occupational series code, e.g. `2210` (IT), `0610` (Nurse), `1102` (Contracting). Leave empty for all series. |
| `maxJobs` | integer | Maximum job announcements to save. `0` = all matching the date range (can be tens of thousands). |

### 🚀 Example input

```json
{
  "startDate": "2026-04-01",
  "endDate": "2026-04-30",
  "keyword": "engineer",
  "hiringDepartmentCodes": ["AF", "VA"],
  "positionSeries": ["2210"],
  "maxJobs": 5000
}
````

### 📦 Output

Each dataset item is one federal job announcement. Main output fields:

| Field | Description |
|---|---|
| `controlNumber` | Unique USAJobs control number for the announcement. |
| `announcementNumber` | Public announcement number. |
| `positionTitle` | Job title. |
| `hiringDepartmentName` | Federal department doing the hiring. |
| `hiringAgencyName` | Hiring agency name. |
| `hiringSubelementName` | Sub-agency or office. |
| `appointmentType` | Appointment type (e.g. permanent, term). |
| `workSchedule` | Full-time, part-time, etc. |
| `serviceType` | Competitive, excepted, or senior executive service. |
| `payScale` | Pay scale system (e.g. GS). |
| `salaryType` | Per year, per hour, etc. |
| `minimumSalary` / `maximumSalary` | Salary range. |
| `minimumGrade` / `maximumGrade` | Grade range. |
| `promotionPotential` | Highest grade the position can be promoted to. |
| `supervisoryStatus` | Whether the role is supervisory. |
| `securityClearance` | Required security clearance level. |
| `travelRequirement` | Expected travel. |
| `teleworkEligible` | Telework eligibility. |
| `relocationExpensesReimbursed` | Whether relocation is reimbursed. |
| `drugTestRequired` | Whether a drug test is required. |
| `whoMayApply` | Eligibility group (e.g. US citizens, federal employees). |
| `totalOpenings` | Number of openings. |
| `hiringPaths` | Array of hiring paths (e.g. veterans, students). |
| `jobCategorySeries` | Array of occupational series for the role. |
| `locations` | Array of work locations. |
| `positionOpenDate` / `positionCloseDate` | Announcement open and close dates. |
| `positionOpeningStatus` | Current status of the announcement. |
| `url` | Direct link to the announcement on USAJobs.gov. |
| `scrapedAt` | Timestamp of when the record was scraped. |

### 💡 Use cases

- **Labor market research** — analyze federal hiring trends by agency, salary, location, and occupational series.
- **Recruitment intelligence** — track who the government is hiring, for what roles, and at what pay grades.
- **Job boards & aggregators** — feed a federal-jobs section with always-fresh, structured data.
- **Economists & journalists** — monitor public-sector employment and hiring volume at scale.
- **Career coaches & staffing firms** — surface relevant federal openings filtered by clearance, series, or department.

### ❓ Frequently Asked Questions

**Is this an official USAJobs API or scraper?**
It pulls data from the official USAJobs.gov API, so the data is authoritative and stable. There is no affiliation with USAJobs or the US government.

**Do I need an API key or login?**
No. The Actor handles everything — you only need an Apify account. There is no USAJobs API key to register.

**Is it legal to use this data?**
USAJobs job announcements are public US government records. Use the data responsibly and in line with USAJobs.gov terms.

**How much data can I get in one run?**
A single run can return tens of thousands of job announcements. Set `maxJobs` to `0` to capture everything matching your date range, or cap it for smaller, faster runs.

**Can I filter the results?**
Yes — filter by date range, title keyword, federal department code, and occupational series code, in any combination.

**How fresh is the data?**
It reflects what is currently published on USAJobs.gov. Schedule the Actor daily or weekly with a rolling date range to keep a continuously updated dataset.

**What output formats are supported?**
JSON, CSV, Excel (XLSX), HTML, and JSONLines, available through the Apify dataset and API.

### ⏰ Scheduling & integration

Schedule the Actor on Apify to run on a rolling date range for a self-updating federal-jobs dataset. Export results to JSON, CSV, or Excel, call it from the Apify API, or connect it to Google Sheets, Airtable, Slack, or your data warehouse with webhooks and no-code tools like Make and Zapier.

***

**Keywords:** usajobs scraper, usajobs api, federal jobs scraper, government job listings, us federal job announcements, federal hiring data, usajobs.gov data, public sector jobs api, federal salary data, gs grade jobs scraper

# Actor input Schema

## `startDate` (type: `string`):

Earliest position open date (YYYY-MM-DD). Leave empty for the last 30 days.

## `endDate` (type: `string`):

Latest position open date (YYYY-MM-DD). Leave empty for today.

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

Free-text keyword matched against the position title, e.g. 'engineer', 'nurse', 'analyst'. Leave empty for all jobs.

## `hiringDepartmentCodes` (type: `array`):

Filter by federal department code, e.g. 'AF' (Air Force), 'VA' (Veterans Affairs), 'TR' (Treasury). Leave empty for all departments.

## `positionSeries` (type: `array`):

Filter by occupational series code, e.g. '2210' (IT), '0610' (Nurse), '1102' (Contracting). Leave empty for all series.

## `maxJobs` (type: `integer`):

Maximum job announcements to save. 0 = all matching the date range (can be tens of thousands).

## Actor input object example

```json
{
  "startDate": "",
  "endDate": "",
  "keyword": "",
  "hiringDepartmentCodes": [],
  "positionSeries": []
}
```

# Actor output Schema

## `positionTitle` (type: `string`):

positionTitle

## `hiringDepartmentName` (type: `string`):

hiringDepartmentName

## `hiringAgencyName` (type: `string`):

hiringAgencyName

## `minimumSalary` (type: `string`):

minimumSalary

## `maximumSalary` (type: `string`):

maximumSalary

## `workSchedule` (type: `string`):

workSchedule

## `positionOpenDate` (type: `string`):

positionOpenDate

## `url` (type: `string`):

url

# 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 = {
    "hiringDepartmentCodes": [],
    "positionSeries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/usajobs-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 = {
    "hiringDepartmentCodes": [],
    "positionSeries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/usajobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "hiringDepartmentCodes": [],
  "positionSeries": []
}' |
apify call logiover/usajobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/usajobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USAJobs Federal Jobs Scraper",
        "description": "Scrape US federal government job announcements from the official USAJobs.gov API — no login, no API key, no blocking. Full hiring details: salary, grade, agency, schedule, clearance, location. Tens of thousands of jobs per run. Schedule it for a fresh federal-jobs feed.",
        "version": "1.0",
        "x-build-id": "Bn2LBoKOYmDM0V5lS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~usajobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-usajobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~usajobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-usajobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~usajobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-usajobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Earliest position open date (YYYY-MM-DD). Leave empty for the last 30 days.",
                        "default": ""
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "Latest position open date (YYYY-MM-DD). Leave empty for today.",
                        "default": ""
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text keyword matched against the position title, e.g. 'engineer', 'nurse', 'analyst'. Leave empty for all jobs.",
                        "default": ""
                    },
                    "hiringDepartmentCodes": {
                        "title": "Hiring Department Codes",
                        "type": "array",
                        "description": "Filter by federal department code, e.g. 'AF' (Air Force), 'VA' (Veterans Affairs), 'TR' (Treasury). Leave empty for all departments.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "positionSeries": {
                        "title": "Position Series",
                        "type": "array",
                        "description": "Filter by occupational series code, e.g. '2210' (IT), '0610' (Nurse), '1102' (Contracting). Leave empty for all series.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxJobs": {
                        "title": "Max Jobs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum job announcements to save. 0 = all matching the date range (can be tens of thousands)."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```