# Job Fair Generator & Career Event Scraper (`thescrapelab/job-fair-generator`) Actor

Discover and export upcoming job fairs from supported public calendars in the US, Canada, UK, and Australia. Filter by location and date; receive deduplicated event data with venues, registration links, and source URLs.

- **URL**: https://apify.com/thescrapelab/job-fair-generator.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 job fair events

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

## Job Fair Generator & Career Event Scraper

Find upcoming **job fairs, career fairs, and hiring events** in public organizer calendars. Get one clean event dataset with dates, locations, venues, eligibility, registration links, and source pages. The Actor is designed for recruiters, staffing teams, job boards, and workforce researchers who need event data they can export or feed into their own tools.

### What you get

Each dataset row represents one unique fair. The Actor currently searches selected calendars in the United States, Canada, United Kingdom, and Australia. You can add public event pages from other countries when they publish Schema.org Event data. Results link to the original source so you can verify details before attending or publishing them.

| Field | Meaning |
| --- | --- |
| `name`, `date`, `endDate`, `timeLocal` | Published event name, local start/end dates, and start time where available |
| `city`, `region`, `countryCode`, `venue` | Published location |
| `organizer`, `eligibility` | Organizer and any stated attendance restriction |
| `registrationUrl`, `sourceUrl` | Registration page and original event listing |
| `eventId`, `collectedAt` | Stable deduplication key and collection time |

Missing details are returned as `null`; the Actor does not guess a venue, registration link, or eligibility rule.

### Example input

Click **Start** with the default input to get up to 10 upcoming events, sampled across all four supported countries and different cities where available. To focus on one city, use:

```json
{
  "countries": ["GB"],
  "city": "London",
  "maxEvents": 20
}
```

The main form has five choices: countries, an optional city, maximum events, and optional start and end dates. Leave the dates blank to search from today through the following year. `maxEvents` defaults to 10 and can be 1–500. Result charges apply only to events delivered to the dataset; a small start charge applies to every run.

Open **Advanced options** for region or postal-code filtering, calendar exclusions, additional source pages, and detail-page controls. Set `city` or `region` for an exact location match. Dates use `YYYY-MM-DD`. `sourceUrls` accepts up to 10 additional public HTTPS pages; pages without usable Event data may return no events. Detail-page visits are on by default, with `maxDetailPages` set to 10 (maximum 100); remaining rows still include listing data. `postalCode` uses an offline GeoNames lookup where a code maps to one place. Codes that map to a neighborhood instead of a city published by the selected calendars return an input error; use `city` in that case. Canadian and UK data may only resolve a code prefix, and no distance radius is calculated.

Use `excludedSources` to skip any built-in calendar you do not want to collect. For example, `{"excludedSources":["ukcareersfair","careerfaircanada"]}` omits those two calendars while keeping the other selected countries. The available IDs are `utexas`, `choicecareerfairs`, `superiorcareerfairs`, `careerfaircanada`, `ukcareersfair`, `bigmeet`, and `nationalcareerexpos`. Review each source's terms and your intended reuse before publishing collected data. Custom pages only yield events whose structured names identify a job, career, graduate, hiring, recruitment, employment, internship, or apprenticeship fair or event. Published end dates and start times are retained; cancelled or postponed structured events are omitted. Virtual fairs with Schema.org `VirtualLocation` are included with `city` set to `Online` when no physical city is published.

### Example output

```json
{
  "eventId": "f15b41154632c70b730b",
  "name": "Perth Careers Fair",
  "date": "2027-03-25",
  "endDate": null,
  "timeLocal": null,
  "city": "Perth",
  "region": "Scotland",
  "countryCode": "GB",
  "venue": "Perth Theatre and Concert Hall",
  "isVirtual": false,
  "organizer": "The UK Careers Fair",
  "eligibility": null,
  "registrationUrl": "https://www.ukcareersfair.com/event/perth-careers-fair/#tickets",
  "sourceUrl": "https://www.ukcareersfair.com/event/perth-careers-fair/",
  "sourceName": "The UK Careers Fair",
  "collectedAt": "2026-09-28T18:02:20.366Z"
}
```

This is a real row from a validation run; dates and links may change. The default dataset can be downloaded as JSON, CSV, or Excel from Apify Console. The run summary reports source counts, detail-page checks, filters, returned events, and any source warnings.

### Use with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("TheScrapeLab/job-fair-generator").call(run_input={
    "countries": ["US", "CA", "GB", "AU"],
    "maxEvents": 20,
})
for event in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(event["date"], event["name"], event["sourceUrl"])
```

### Coverage and freshness

#### Use cases

- Add upcoming career fairs to a job board or recruiter newsletter.
- Track hiring events by city and date for outreach planning.
- Compare event calendars across supported markets and verify each listing at its source.

#### Limitations

Current built-in calendars include UT Austin's career-fair calendar, [Choice Career Fairs](https://choicecareerfairs.com/career-fairs), [Superior Career Fairs](https://www.superiorcareerfairs.com/), Career Fair Canada, The UK Careers Fair, Australia's Big Meet, and [National Careers & Employment Expos](https://www.careersemploymentexpo.com.au/). The Career Fair Canada calendar follows up to five listing pages when the source offers them. These are selected public sources, **not an exhaustive list of every fair in a city or country**. Events can change or be cancelled after collection; confirm details on the linked organizer page. Some university events are limited to students or alumni; inspect `eligibility` before promoting a fair to a wider audience. Fairs listed for a broad area, such as Northern Kentucky/Cincinnati, are omitted when the calendar does not identify one city clearly.

The Actor uses public web pages. It does not sign in, request source APIs, or bypass blocked pages. If one calendar is temporarily unavailable, other calendars can still return results, and the run summary identifies the affected source. A narrow city/date filter can legitimately return an empty dataset. Events from additional countries supplied through `sourceUrls` can appear alongside the built-in country sample.

Postal place names are derived from [GeoNames](https://www.geonames.org/) postal-code downloads under Creative Commons Attribution 4.0; the data can be incomplete or stale.

### Pricing and support

The launch price is **$0.0005 per unique event delivered** in the default dataset, plus **$0.00005 when a run starts**. Platform usage is included. Detail-page visits, duplicates, filtered-out events, and the run summary have no separate charge. An empty result has only the start charge. Check the Pricing tab for the live price before running.

| Events delivered | Approximate run charge |
| ---: | ---: |
| 0 | $0.00005 |
| 10 | $0.00505 |
| 100 | $0.05005 |

Set a maximum run charge to control spend. If the limit allows fewer rows than the search finds, the Actor returns only the rows covered by the limit and marks the run summary as partial. For a parsing or coverage issue, include the source URL, run ID, and expected event in an Apify issue so it can be reproduced.

# Actor input Schema

## `countries` (type: `array`):

Choose one or more built-in markets. All four are selected by default.

## `city` (type: `string`):

Enter an exact city name, such as London. Leave blank to include all cities in the selected countries.

## `maxEvents` (type: `integer`):

Return up to this many unique events. The default is 10. Each delivered event has a per-event charge, plus a small charge when the run starts.

## `dateFrom` (type: `string`):

Earliest event date. Leave blank to start from today.

## `dateTo` (type: `string`):

Latest event date. Leave blank to search one year from the start date.

## `region` (type: `string`):

Optional exact region text published by a calendar. Leave blank for all regions.

## `postalCode` (type: `string`):

Optional postal code. Only codes that map confidently to a city in the built-in offline lookup are accepted; this is not a radius search.

## `excludedSources` (type: `array`):

Skip specific calendars. Leave empty to use all calendars in your selected countries. If you exclude them all, add a source URL below.

## `sourceUrls` (type: `array`):

Optional HTTPS career-fair pages, including pages from other countries. Pages with Schema.org Event data work best.

## `includeDetails` (type: `boolean`):

On by default. Visit linked event pages to find registration and eligibility details when available.

## `maxDetailPages` (type: `integer`):

Visit up to this many event pages when detail visits are on. Other events still return listing data.

## Actor input object example

```json
{
  "countries": [
    "US",
    "CA",
    "GB",
    "AU"
  ],
  "maxEvents": 10,
  "excludedSources": [],
  "sourceUrls": [],
  "includeDetails": true,
  "maxDetailPages": 10
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Unique, source-linked job fair records.

## `runSummary` (type: `string`):

Source coverage, filters, selected and delivered counts, budget limits, and warnings.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/job-fair-generator").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/job-fair-generator").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 '{}' |
apify call thescrapelab/job-fair-generator --silent --output-dataset

```

## MCP server setup

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

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/XSVLw07fbpRhvGpB5/builds/ilrK0q50ONEyj6Pa0/openapi.json