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

Scrape USAJobs.gov federal job listings without an API key. Export to CSV/JSON - a USAJobs API alternative & federal jobs data extraction tool.

- **URL**: https://apify.com/logiover/usajobs-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 19 total users, 4 monthly users, 100.0% runs succeeded, 0 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 Jobs 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 federal jobs scraper pulls every public-sector job posting with full hiring details: salary, GS 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 CSV, JSON or Excel.

---

### What you get

One dataset record per federal job announcement. Main output fields:

- `controlNumber` / `announcementNumber` — unique and public announcement identifiers
- `positionTitle` — job title
- `hiringDepartmentName` / `hiringAgencyName` / `hiringSubelementName` — hiring org
- `appointmentType` / `serviceType` — permanent / term, competitive / excepted service
- `workSchedule` — full-time, part-time, etc.
- `payScale` / `salaryType` — pay system (e.g. GS) and basis
- `minimumSalary` / `maximumSalary` — salary range
- `minimumGrade` / `maximumGrade` / `promotionPotential` — grade range
- `supervisoryStatus` / `securityClearance` / `travelRequirement` — role attributes
- `teleworkEligible` / `relocationExpensesReimbursed` / `drugTestRequired` — eligibility flags
- `whoMayApply` / `hiringPaths` — eligibility group and hiring paths
- `jobCategorySeries` / `locations` — occupational series and work locations
- `positionOpenDate` / `positionCloseDate` / `positionOpeningStatus` — announcement dates and status
- `url` — direct link to the announcement on USAJobs.gov
- `scrapedAt` — scrape timestamp

---

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

---

### How to use

1. **Set a date range** — scrape announcements opened within a window (empty = last 30 days).
2. **Add filters** — keyword on the title, federal department code, occupational series — in any combination.
3. **Run & export** — download as CSV, JSON or Excel, or schedule a rolling date range for a self-updating federal-jobs dataset.

#### Example input

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

#### Input fields

| Field | Description |
|---|---|
| `startDate` / `endDate` | Position open-date window (`YYYY-MM-DD`). Empty = last 30 days / today. |
| `keyword` | Free-text match on the position title (e.g. `engineer`, `nurse`, `analyst`). |
| `hiringDepartmentCodes` | Department codes, e.g. `AF` (Air Force), `VA` (Veterans Affairs), `TR` (Treasury). |
| `positionSeries` | Occupational series codes, e.g. `2210` (IT), `0610` (Nurse), `1102` (Contracting). |
| `maxJobs` | Max announcements to save. `0` = all matching (can be tens of thousands). |

***

### FAQ

#### 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 and no proxy required.

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

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

#### Is this a USAJobs API alternative?

Yes. It wraps the official USAJobs.gov API and turns it into clean, ready-to-use records, so you skip API-key registration, pagination and parsing. Use it as a USAJobs API alternative when you just want the structured job data.

#### How do I export USAJobs data to CSV or JSON?

Run the actor, then download the dataset as CSV, JSON or Excel from the Apify console or pull it via the API. Schedule a rolling date range to keep a self-updating federal jobs dataset.

#### Can I scrape USAJobs.gov without an API key?

Yes. There is no USAJobs API key to register and no login or proxy required — the actor handles federal government jobs data extraction end to end.

***

**Keywords:** usajobs scraper, usajobs api, federal jobs scraper, government job listings, us federal job announcements, federal hiring data, public sector jobs api, federal salary data, gs grade jobs scraper, usajobs api alternative, usajobs data export csv, federal jobs dataset json, scrape usajobs without api key.

***

### Changelog

#### 2026-06-15

- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.

#### 2026-06-07

- Docs: added coverage for USAJobs API alternative usage, exporting federal jobs data to CSV/JSON, and scraping USAJobs.gov without an API key.

#### 2026-06-05

- 🛡️ Reliability fix: results are no longer dropped by strict output validation — runs now complete cleanly even at high volume (thousands of results).
- ⚡ Stability & performance hardening; fresh rebuild.

#### 2026-06-04

- Verified live & refreshed build — reliability/maintenance pass.

# 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": [],
  "maxJobs": 100
}
```

# 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": [],
    "maxJobs": 100
};

// 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": [],
    "maxJobs": 100,
}

# 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": [],
  "maxJobs": 100
}' |
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 Scraper - Federal Government Jobs Data",
        "description": "Scrape USAJobs.gov federal job listings without an API key. Export to CSV/JSON - a USAJobs API alternative & federal jobs data extraction tool.",
        "version": "1.0",
        "x-build-id": "DK1ySwk22OL4uHM0X"
    },
    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
