# O\*NET Skill & Software Records — Occupation Associations (`nexgensignal/onet-skill-software-records`) Actor

Keyless, pay-per-record O*NET data. One row per occupation-to-skill or occupation-to-software association — SOC code, occupation, element, O*NET rating or hot-technology/in-demand flags. CC BY 4.0; occupation grain, no person data.

- **URL**: https://apify.com/nexgensignal/onet-skill-software-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 association records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## O\*NET Skill & Software Records — Occupation Associations

**Keyless. Pay per record. Every occupation's skills and software, as one clean association table.**

This actor turns the **O\*NET database** (the U.S. Department of Labor's occupational data system) into clean, per-association records — the map of which skills and which software each occupation uses. Each run reads O*NET's keyless bulk database and delivers one row per occupation-to-element link: the occupation, the skill or software element, and the O*NET rating or flags that describe it. Occupation-to-skill / occupation-to-software grain, structured for engineering use, under the Creative Commons Attribution 4.0 licence, with no personal data of any kind.

### What this is, in one paragraph

O*NET describes roughly a thousand occupations along hundreds of dimensions. Two of those dimensions matter most for skills intelligence: the **skills** an occupation requires (with O*NET's importance and level ratings) and the **software / technology** an occupation uses (with O*NET's hot-technology and in-demand flags). This actor flattens both into a single association table — one record per occupation-element pair — so you can answer "which occupations use Python," "what skills matter most for this role," or "how does this job's technology profile compare to that one" with a plain join instead of parsing O*NET's file bundle by hand. Values are exactly as O\*NET publishes them. You are billed only for records actually delivered.

### Who buys this and for what job

- **Workforce-analytics and talent-intelligence products** that need occupation→skill and occupation→software mappings as clean rows to power role taxonomies, skill graphs, and gap analysis.
- **HR-tech, job-matching, and resume-parsing tools** aligning free-text roles to a standard skill and technology vocabulary.
- **Labor-market researchers and economists** studying skill demand, technology adoption, and how tooling differs across occupations.
- **Data engineers** who want the O\*NET skills and technology-skills tables joined and normalized without downloading and reshaping the raw database bundle.

### Creative Commons Attribution 4.0 — free commercial reuse

One licence rider travels on every record. The O*NET database is published by USDOL/ETA under the **Creative Commons Attribution 4.0 International (CC BY 4.0)** licence — free to copy, publish, distribute, and adapt, **including commercially**, with the required attribution: "This product incorporates information from the O*NET database, used under CC BY 4.0. O\*NET is a trademark of USDOL/ETA." That attribution string is carried on every record and in this README so downstream users always have it. This is occupational reference data — a description of work, not a directory of workers.

### Occupation grain — no person data

This actor works at occupation grain: the unit of every record is an occupation (an O*NET-SOC code), never a person. O*NET contains no natural-person data — it describes jobs, not job-holders — and this actor emits none. Occupation titles, skill and software element names, rating values, and O\*NET flags are the entire payload; a person-key guard runs on every record as a pure backstop and the acceptance suite feeds a deliberately person-shaped row and asserts none of it can ever appear in output.

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `association_record` | $0.05 | $0.045 | $0.04 | $0.0335 |

Delivered before charged. Blocked runs and empty results cost nothing.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `associationType` | string | all | `all`, `skill`, or `software`. |
| `onetSocCodePrefix` | string | — | Optional. Keep only occupations whose O*NET-SOC code starts with these digits (e.g. `15` for computer/math, `29-1141.00` for one occupation). |
| `elementContains` | string | — | Optional. Keep only associations whose element name contains this text (e.g. `Python`, `welding`, `negotiation`). |
| `hotTechnologyOnly` | boolean | false | Software only: keep only technologies O*NET flags as a Hot Technology. |
| `maxRecords` | integer | 500 | Ceiling on records delivered and billed. |

### Output

One JSON object per occupation-element association. Real examples (values as published by O\*NET):

```json
{
  "record_id": "15-1252.00:software:2.E.5.b:",
  "association_type": "software",
  "onet_soc_code": "15-1252.00",
  "occupation_title": "Software Developers",
  "skill_class": null,
  "element_id": "2.E.5.b",
  "element_name": "Web platform development software",
  "scale_id": null,
  "data_value": null,
  "software_example": "Python",
  "hot_technology": true,
  "in_demand": false,
  "source": "O*NET database (db_30_3), USDOL/ETA",
  "licence": "O*NET database ... CC BY 4.0 ...",
  "attribution": "This product incorporates information from the O*NET database, used under CC BY 4.0 ...",
  "disclaimer": "Occupation-to-skill and occupation-to-software association records ... no natural-person data ...",
  "observed_at": "2026-08-21T00:00:00Z"
}
```

A skill association instead carries `scale_id` (`IM` importance or `LV` level), a numeric `data_value`, and a `skill_class` of `essential` or `transferable`, with the software fields null. An unbilled `RUN_RECEIPT` records the robots check, the filters, rows seen and delivered, and whether charged equals delivered.

### Field reference

Each record is one occupation-element association. Identity: `record_id` (SOC code + type + element id + scale), `association_type` (`skill` / `software`), `onet_soc_code`, and `occupation_title`. Element: `element_id` and `element_name`. Skill-only: `skill_class` (`essential` / `transferable`), `scale_id` (`IM` / `LV`), and `data_value` (the O\*NET rating). Software-only: `software_example` (the technology example), `hot_technology`, and `in_demand`. Provenance: `source`, `source_url`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

A run first re-reads the source host's robots posture from your runtime — the O*NET Resource Center — and confirms the database download path is allowed, stopping at the door if a Disallow ever covers it. It then fetches the O*NET database bundle once, reads the skills and technology-skills tables, joins each row to its occupation title, and flattens it to one association record — reading only occupation, element, rating, and flag fields, never anything person-shaped — delivered **before** it is charged, so a blocked or empty run costs you nothing. Your `associationType`, `onetSocCodePrefix`, `elementContains`, and `hotTechnologyOnly` filters are applied before delivery, and the actor stops at your `maxRecords` ceiling and records `charge_equals_delivered` in the receipt.

### Coverage and scope

The database holds on the order of **94,000+ occupation-element associations** across roughly a thousand O\*NET-SOC occupations — the essential-skills and transferable-skills tables together (importance and level ratings) plus the technology-software table (with hot-technology and in-demand flags). Because every record carries the `onet_soc_code`, associations join cleanly to any occupation-keyed dataset, and `element_name` lets you pivot the other way — from a skill or a technology to every occupation that uses it. Pull one occupation family with an `onetSocCodePrefix`, one technology with `elementContains`, or the whole table to seed a skills graph.

### Working with the associations

The two association types answer different questions and share one key. Skill rows tell you **how important** a skill is to an occupation and **what level** it demands — the `IM` and `LV` scale values let you rank skills within a role or compare the same skill across roles. Software rows tell you **which technologies** a role uses and whether O\*NET considers each one a hot or in-demand technology — useful for tooling-adoption analysis and for aligning a candidate's stack to a role. Because both share `onet_soc_code`, a single occupation's full profile is one filtered pull, and because both carry `element_name`, the inverse lookup — every occupation that uses a given skill or technology — is equally direct. The `hot_technology` and `in_demand` flags travel verbatim so a downstream model can weight emerging tools without re-deriving that signal.

### Cost guidance

One `association_record` per delivered row: cost = rows delivered × your plan's per-record price. Scope with `onetSocCodePrefix`, `associationType`, or `elementContains` to keep runs bounded — one occupation family or one technology is typically a few hundred to a few thousand rows. 1,000 associations is **$50** (Free) / **$33.50** (Gold); the full ~94,000-row table is a one-time seed you can then keep fresh with small targeted pulls.

### Honest limitations

- **Reference, not a roster.** This is occupational reference data describing work — skills and software by occupation — not a list of people, employers, or job postings.
- **As published.** Ratings, flags, element names, and titles are exactly as O\*NET distributes them; this actor reformats, it does not recompute or re-survey.
- **Two association types.** Skill rows carry ratings; software rows carry technology examples and flags — the unused fields are null by design, not missing data.
- **No person data** of any kind.

### Differentiation

This is a **net-new** category for the NexGenData fleet — no existing fleet actor covers O*NET occupation-to-skill or occupation-to-software associations. It is distinct from any jobs, hiring, or staffing cell (those carry postings or headcounts, not the standardized skill/technology vocabulary) and from generic occupation directories. Its specific job is the \*\*O*NET skills-and-software association table\*\* — the reference mapping that skills-intelligence, talent, and labor-market systems join against.

### The NexGen Signal family

Part of the NexGen Signal family of pay-per-record data products:

- [US Hospital Ownership Records — CMS Owner Edges](https://apify.com/nexgensignal/us-hospital-ownership-records)
- [Higher-Ed Institution Records — US IPEDS](https://apify.com/nexgensignal/higher-education-institution-records)
- [Grant Opportunity Records — US Grants.gov](https://apify.com/nexgensignal/grant-opportunity-records)
- [Mine Operator & Safety Records — US MSHA](https://apify.com/nexgensignal/mine-operator-safety-records)
- [Airport Facility Records — US FAA NASR](https://apify.com/nexgensignal/airport-facility-records)

*Source: O*NET database (db\_30\_3), U.S. Department of Labor, Employment and Training Administration (onetcenter.org). O*NET data is used under the Creative Commons Attribution 4.0 International (CC BY 4.0) licence — free to reuse, including commercially, with attribution. O*NET is a trademark of USDOL/ETA. Occupation-level reference data; no person data of any kind.\*

# Actor input Schema

## `onetSocCodePrefix` (type: `string`):

Optional. Keep only occupations whose O\*NET-SOC code starts with these digits (e.g. 15 for computer/math, 15-1252, 29-1141.00).

## `associationType` (type: `string`):

Which associations to return.

## `elementContains` (type: `string`):

Optional. Keep only associations whose skill or software element name contains this text (e.g. Python, welding, negotiation).

## `hotTechnologyOnly` (type: `boolean`):

Software only: keep only technologies O\*NET flags as a Hot Technology.

## `maxRecords` (type: `integer`):

Maximum records delivered and billed.

## Actor input object example

```json
{
  "associationType": "all",
  "hotTechnologyOnly": false,
  "maxRecords": 500
}
```

# Actor output Schema

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

Delivered records.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/onet-skill-software-records").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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/onet-skill-software-records").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/onet-skill-software-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/onet-skill-software-records"
        }
    }
}

```

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/klsVibJwjGjueGqu7/builds/Ur3mUld5z0DcLMq5R/openapi.json