# Jobboard Guard (`lavender_spinel/jobboard-guard`) Actor

- **URL**: https://apify.com/lavender_spinel/jobboard-guard.md
- **Developed by:** [Rashidul Hasan](https://apify.com/lavender_spinel) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 audited job pages

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## JobBoard Guard

An Apify Actor for checking authorized recruitment websites for expired job listings, malformed or missing Google JobPosting JSON-LD, missing application links, and other technical quality issues.

### Features

- Find likely job pages from robots.txt XML sitemaps and homepage links.
- Inspect JSON-LD JobPosting fields, expiry wording, published dates and apply links.
- Respect robots.txt, restrict to same website and public DNS, and cap requests.
- Export records to Apify Dataset, JSON to SUMMARY, and a styled HTML report to REPORT in the key-value store.
- Compare issues between repeated runs in a scheduled named Apify Task.
- Supports pay-per-event with event **job-page-audited**, when configured in Apify Console.

### Try it immediately (offline preview)

Leave both URL fields empty and click Start. The Actor analyzes **three explicitly labeled synthetic JobPosting examples** (valid, expired, and missing fields) without visiting any website. The output is not a report about any real employer. No paid page-audit events are emitted for examples; the separately configured tiny Actor-start charge may still apply.

### Usage

Supply either `sites` (recruitment website homepages), `jobUrls` (specific job detail URLs) or both. Check the authorization checkbox. Limit pages for initial tests.

Example:

```json
{"sites":[],"jobUrls":["https://example.com/jobs/your-posting"],"authorized":true,"maxTotalPages":3,"secondsBetweenRequests":1}
```

The example URL is illustrative only: do not run against a site you do not have permission to audit. For an actual scan, provide a permitted site or direct job URL and check the authorization checkbox.

This first release checks server-rendered HTML and JSON-LD. It does not run JavaScript, submit job applications, certify Google eligibility, or verify the live functioning of application pages. An expired date in validThrough is not itself a violation. If a website does not expose job detail URLs in its sitemap or homepage, supply the URLs explicitly.

### Pricing and publishing

Recommended **test price**: USD $0.02 per successful page audit. Event name: `job-page-audited`. Set the event and pricing separately in Apify Console. The software alone does not enable payment collection.

Before public release, test actual authorized job URLs, inspect dataset/report and operating costs, then complete marketplace registration and payout onboarding. Publishing and earnings are not guaranteed.

### Deployment

This repository is linked to Apify under a Git-based Actor. After the source is committed to main, Apify can build it automatically. The code uses Python 3.12 and the Apify Python SDK, with an input schema at `.actor/input_schema.json`.

Local unit tests: `PYTHONPATH=src pytest -q`.

### Security

The crawler rejects private/non-public destinations, restricts redirects to the same domain, honors robots.txt, uses bounded response sizes, and never bypasses authentication. Only audit sites you own, manage, or have permission to inspect.

This is an independent tool not affiliated with Google or Apify.

# Actor input Schema

## `sites` (type: `array`):

Enter one or more authorized recruitment websites for a live audit. Leave both URL fields blank for sample reports.

## `jobUrls` (type: `array`):

Optional: up to 80 direct job-page URLs for a live audit. Do not enter URLs you lack permission to inspect.

## `authorized` (type: `boolean`):

Required for live website scanning. Not needed for the built-in offline sample.

## `maxPagesPerSite` (type: `integer`):

Maximum job pages per website.

## `maxTotalPages` (type: `integer`):

Controls run cost and load.

## `secondsBetweenRequests` (type: `integer`):

Minimum 1 second to reduce load.

## `comparePreviousRuns` (type: `boolean`):

Compare page results across runs of the same Apify Task.

## Actor input object example

```json
{
  "sites": [],
  "jobUrls": [],
  "authorized": false,
  "maxPagesPerSite": 30,
  "maxTotalPages": 50,
  "secondsBetweenRequests": 1,
  "comparePreviousRuns": true
}
```

# Actor output Schema

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

JSON records for every analyzed URL, including observed issues and recommendations.

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

Counts, page statuses, discovery diagnostics and differences from the prior scheduled run.

## `htmlReport` (type: `string`):

Human-readable responsive HTML report showing page-by-page findings.

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

// Run the Actor and wait for it to finish
const run = await client.actor("lavender_spinel/jobboard-guard").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 = {
    "sites": [],
    "jobUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("lavender_spinel/jobboard-guard").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 '{
  "sites": [],
  "jobUrls": []
}' |
apify call lavender_spinel/jobboard-guard --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lavender_spinel/jobboard-guard"
        }
    }
}
```

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/7PCLGDMSCpCKnuRY9/builds/pz67pFTHDhNpHiLYO/openapi.json