# Miss Opportunity — Job Scam Checker & Posting Parser (`honorable_mettle/job-posting-intelligence`) Actor

Normalize up to 100 job postings per run into salary, skills, requirements and review-ready JSON. Explainable scam-warning signals include matched wording. Built for job boards and AI workflows; no external AI key. $9.99/1,000 analyses plus platform usage. Signals do not prove fraud.

- **URL**: https://apify.com/honorable_mettle/job-posting-intelligence.md
- **Developed by:** [Aaron DeBaca](https://apify.com/honorable_mettle) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.99 / 1,000 job posting analyses

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does Miss Opportunity do?

**Turn job-ad text into structured JSON and explainable scam-warning signals.** Miss Opportunity is a deterministic job posting parser for job-board operators, automation builders, recruiters, and AI agents. Supply text or HTML you already have; no external AI API key is required.

[Try the ready-to-run job scam checker demo](https://apify.com/honorable_mettle/job-posting-intelligence/examples/job-posting-intelligence-task). It contains two fictional postings, and you can replace them with your own text.

### Why use this job posting parser?

- **Job boards:** normalize salary and requirements from imported descriptions, then route warnings to human review.
- **Automation workflows:** get consistent JSON through Apify API access, scheduling, integrations, and monitoring.
- **Recruiters and job seekers:** inspect missing details and warning patterns before spending time on a posting.

#### What the demo actually returned

A two-posting test on October 3, 2026 completed successfully in about two seconds. These are illustrative results from fictional inputs, not a measured accuracy rate.

| Sample | Extracted pay | Risk score | Warning signals |
| --- | --- | --- | --- |
| Warehouse Associate | USD 20–24/hour | 0, minimal | None detected in the supplied wording |
| Remote Data Entry | USD 45/hour | 100, high | Upfront payment, check scheme, chat-only interview |

**A score of 0 does not verify an employer. A score of 100 is not a probability or proof of fraud.** The score ranks wording signals for review.

### How to try it

1. Open the [prefilled demo](https://apify.com/honorable_mettle/job-posting-intelligence/examples/job-posting-intelligence-task) or the Actor's Input tab.
2. Replace the fictional descriptions with your own posting text, or start with the two samples.
3. Run the Actor and inspect the dataset. You can download results as JSON, HTML, CSV, or Excel.
4. Review the evidence behind each warning and check the employer's official listing independently.

The analysis event price is **$0.00999 per valid posting**: one posting is about one cent, ten are $0.0999, and 1,000 are $9.99, before any additional platform charges. See the Pricing tab for current billing details.

### Employer-page verification limits

Miss Opportunity extracts structured details and flags warning signs in supplied job text. For Sysco listings linked to the exact official careers.sysco.com domain, it attempts to compare the supplied job ID, title, compensation range, and explicit pay period with the employer page. Matching numbers with a different pay period are conflicting; missing periods remain unverified. The verification field reports matched, conflicting, or unverified with a check time and reason. A match covers those fields at that moment; it does not authenticate a recruiter or guarantee an active opening. Other employers and unreadable pages remain unverified. A low risk score screens wording only and is not a legitimacy verdict. Check the employer careers site before sharing personal information. No external AI API is used.

### What buyers receive

Each valid posting produces one dataset item containing:

- title, company, location, and source identity
- normalized compensation range and pay period
- employment type, work modality, and schedule signals
- skills, experience, education, licenses, and physical requirements
- benefits and contact information
- explainable scam-risk signals, risk score, and missing-field report
- a separate verification status with reasons and a check time when an official Sysco page can be checked

### Input

Submit either `job` or `jobs`. A job may contain:

```json
{
  "id": "customer-reference",
  "sourceUrl": "https://example.com/job/123",
  "text": "Raw job posting text",
  "html": "<p>Raw job posting HTML</p>",
  "title": "Optional supplied title",
  "company": "Optional supplied company",
  "location": "Optional supplied location"
}
```

If both `text` and `html` are present, `text` is used. A run accepts up to 100 postings. Invalid postings are rejected without a result charge.

### Output

Results are written individually to the default dataset. A run summary with `results` and rejected-input `errors` is saved under the `OUTPUT` key-value-store record.

### Pricing

The published pay-per-event price is **$0.00999 per job analysis** ($9.99 per 1,000). Each valid posting may produce one chargeable result. The Actor checks the caller's remaining analysis-event budget before saving a result, then charges the job-analysis event only after the dataset save succeeds. A dataset save failure does not trigger that analysis event. A later charging or summary-write failure can still fail a run after results have been delivered; inspect the dataset as well as the run status. This is not an atomic transaction or a refund guarantee. Consult the Pricing tab for the current price and any Apify platform charges.

### Local test

```bash
npm install
npm test
apify actor:call --input-file INPUT.example.json
```

To exercise the pay-per-event test ledger locally:

```bash
ACTOR_TEST_PAY_PER_EVENT=true npm start
```

### Limits and safety

- This is deterministic extraction, not legal, employment, or fraud-investigation advice.
- Risk indicators are explainable warnings, not proof that an employer or posting is fraudulent.
- Supply posting text or HTML. A `sourceUrl` alone is not analyzed. For an exact HTTPS `careers.sysco.com` listing, the Actor may fetch that official page to compare a limited set of fields; other employers and unreadable pages remain unverified.
- Results should be verified before consequential employment decisions.

### Try it with one posting

Paste this JSON into the Input tab and click Start:

```json
{
  "job": {
    "title": "Will Call Associate",
    "company": "Example Food Distributor",
    "text": "Full-time Will Call Associate in Maryland. Pay is $18 to $22 per hour. Process customer orders, prepare invoices, collect customer payments at the service desk, and coordinate pickups. Requires one year of customer service experience and basic data entry skills."
  }
}
```

The output separates compensation, requirements, and risk signals. Routine customer payments are not by themselves evidence of a scam. If a posting tells you to route funds through your own bank account or forward checks, investigate before sharing personal information. The score is a screening aid, not a legitimacy verdict.

### Batch workflow for job boards and automation builders

Normalize up to 100 descriptions per run into one JSON record per valid posting. Preserve your own `id` to join results back to the original rows. Use the Apify API to call this Actor after collecting descriptions, then export the dataset to your database or spreadsheet. Route warnings to human review; do not automatically reject employers or applicants based on the score.

```json
{"jobs":[{"id":"warehouse-001","title":"Warehouse Associate","company":"Example Distribution","location":"Maryland","text":"Full-time warehouse associate. Pay is $20 to $24 per hour. Forklift experience required. Health insurance and paid time off."},{"id":"review-002","title":"Data Entry","company":"Example Listing","location":"Remote","text":"Remote data entry. Pay is $45 per hour. Send a training fee and deposit a check to buy equipment. Interview via Telegram."}],"includeCleanText":false}
```

The first record should have USD 20–24/hour compensation and no detected wording warnings. The second should trigger upfront-payment, check-scheme, and chat-interview warnings. These are fictional examples, not verified jobs. Warning signals include the matched wording in `evidence` where available.

#### API example (Node.js)

```javascript
const token = process.env.APIFY_TOKEN;
if (!token) throw new Error("Set APIFY_TOKEN in your environment");
const response = await fetch(
  "https://api.apify.com/v2/acts/honorable_mettle~job-posting-intelligence/run-sync-get-dataset-items",
  { method: "POST", headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
    body: JSON.stringify({ jobs: [{ id: "row-1", text: "Full-time warehouse role. Pay is $20 per hour." }] }) }
);
if (!response.ok) throw new Error(`Apify request failed: ${response.status}`);
const results = await response.json();
console.log(results);
```

Use asynchronous Actor runs and retrieve the dataset afterward for longer workflows. Consult the Actor API tab for the current endpoints and platform limits. Keep tokens in environment variables, outside public code.

#### Invalid records and incomplete batches

Invalid records produce entries in the `OUTPUT.errors` summary, rather than chargeable dataset results. HTML containing no readable text is rejected. Out-of-range numeric HTML entities are safely removed. The summary includes `submitted`, `processed`, `rejected`, `notProcessed`, and `spendingLimitReached`, so your workflow can detect missing results. An empty input or more than 100 postings fails with an explanatory message.

#### Accuracy boundaries

Extraction is English-language and rule-based. Compensation recognition currently focuses on dollar-denominated amounts and common spelled-out pay periods; other currencies, abbreviated ranges, negated wording, and unusual formatting may be missed or misread. Skills come from a fixed vocabulary. `quality.confidence` is a completeness heuristic, not a measured probability of correctness. Missing salary and a consumer email address alone are not proof of a scam. No general accuracy percentage is claimed. Use the Issues tab to report a reproducible example with personal information removed.

### Regression validation — October 14, 2026

Build 0.0.22 completed a 13-record synthetic regression batch in about two seconds: 10 valid records produced results and 3 invalid records were rejected with explicit errors. Checked expectations covered hourly and annual ranges; weekly, monthly, and daily pay; ordinary customer payments; upfront-fee/check/chat warning signals; personal-account transfers; HTML cleanup with invalid numeric entities; missing compensation; and empty/null records. A separate low-cap run stopped early without crashing. This small, authored test set confirms these specific behaviors only. It does not establish accuracy on real listings, verify employers, or demonstrate customer adoption.

#### Delivery and billing validation — October 14, 2026

Six mocked control-flow cases checked successful save-before-charge ordering, dataset-save failure without an analysis charge, zero remaining event budget without delivery, retaining the final delivered result when the charge limit is reached, non-pay-per-event delivery, and a charging failure after delivery. These are synthetic unit checks, not live customer billing tests. The default results table now includes employer-page verification evidence, reasons, and limitations separately from wording signals. Platform charges and storage behavior remain governed by Apify; no privacy, retention, or refund guarantee is added.

# Actor input Schema

## `job` (type: `object`):

Paste the posting text here. The sample is illustrative and will produce one result if run.

## `jobs` (type: `array`):

Up to 100 postings. Each item may contain id, text, html, sourceUrl, title, company, and location.

## `includeCleanText` (type: `boolean`):

Return normalized source text in each result.

## Actor input object example

```json
{
  "job": {
    "title": "Will Call Associate",
    "company": "Example Food Distributor",
    "location": "Maryland",
    "text": "Full-time Will Call Associate in Maryland. Pay is $18 to $22 per hour. Process customer orders, prepare invoices, collect customer payments at the service desk, and coordinate pickups. Requires one year of customer service experience and basic data entry skills."
  },
  "includeCleanText": false
}
```

# Actor output Schema

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

Compensation, requirements, benefits, risk, and quality signals.

# 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 = {
    "job": {
        "title": "Will Call Associate",
        "company": "Example Food Distributor",
        "location": "Maryland",
        "text": "Full-time Will Call Associate in Maryland. Pay is $18 to $22 per hour. Process customer orders, prepare invoices, collect customer payments at the service desk, and coordinate pickups. Requires one year of customer service experience and basic data entry skills."
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("honorable_mettle/job-posting-intelligence").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 = { "job": {
        "title": "Will Call Associate",
        "company": "Example Food Distributor",
        "location": "Maryland",
        "text": "Full-time Will Call Associate in Maryland. Pay is $18 to $22 per hour. Process customer orders, prepare invoices, collect customer payments at the service desk, and coordinate pickups. Requires one year of customer service experience and basic data entry skills.",
    } }

# Run the Actor and wait for it to finish
run = client.actor("honorable_mettle/job-posting-intelligence").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 '{
  "job": {
    "title": "Will Call Associate",
    "company": "Example Food Distributor",
    "location": "Maryland",
    "text": "Full-time Will Call Associate in Maryland. Pay is $18 to $22 per hour. Process customer orders, prepare invoices, collect customer payments at the service desk, and coordinate pickups. Requires one year of customer service experience and basic data entry skills."
  }
}' |
apify call honorable_mettle/job-posting-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,honorable_mettle/job-posting-intelligence"
        }
    }
}
```

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/Kq2adtTrh2Jr5MTqB/builds/YI7Z05ls12KMch5QN/openapi.json