# Talent.com Jobs Scraper (`cirkit/talent-com-jobs-scraper`) Actor

Search talent.com job listings across 21 country markets. Every row carries the salary band, city and lat/lon, O\*NET occupation code, employment type, remote flag, full description text and the direct ATS apply link, not a talent.com redirect.

- **URL**: https://apify.com/cirkit/talent-com-jobs-scraper.md
- **Developed by:** [Crikit](https://apify.com/cirkit) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.70 / 1,000 job returneds

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/platform/actors/running/actors-in-store#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

## Talent.com Jobs Scraper

Talent.com Jobs Scraper turns any talent.com search into clean, structured job data. Give it keywords and locations, or paste search URLs, and it returns one row per listing with the salary band, geocoded location, O\*NET occupation code, employment type, remote flag, posting dates, source ATS and the employer's own apply link.

It runs across **21 country markets**, needs no login, no API key and no residential proxy, and it is the cheapest talent.com scraper on the Apify Store.

### What you get for every job

| Field group | Fields |
|---|---|
| Identity | `jobId`, `legacyJobId`, `jobUrl` |
| Role | `title`, `normalizedTitle`, `company`, `jobTypes`, `category`, `isRemote` |
| Pay | `salaryMin`, `salaryMax`, `salaryAverage`, `salaryCurrency`, `salaryPeriod`, `salaryIsPublic` |
| Place | `location`, `city`, `region`, `countryCode`, `latitude`, `longitude` |
| Classification | `onetSocCode`, `onetSocTitle`, `language` |
| Description | `descriptionText`, `descriptionHtml`, `descriptionIsTruncated` |
| Application | `applyUrl`, `applyType`, `sourceAts`, `sourceFeedCode` |
| Freshness | `datePosted`, `dateRefreshed`, `dateExpires`, `isSponsored` |
| Provenance | `searchKeyword`, `searchLocation`, `market`, `searchPage`, `searchUrl`, `scrapedAt` |

Two of those are worth calling out, because most job scrapers do not carry them:

- **`applyUrl` is the employer's real application link** on their own applicant tracking system, such as Workable, Greenhouse, Lever, SmartRecruiters or JazzHR. It is not a talent.com redirect, so you can route candidates or enrich employers directly.
- **`onetSocCode`** is the US Bureau of Labor Statistics O\*NET-SOC occupation code, for example `15-1252.00` for software developers. It lets you join scraped listings straight onto official occupation, wage and employment statistics without building your own title-matching layer.

`salaryMin` and `salaryMax` are `null` when the employer published no salary, never `0`. That distinction matters: a scraper that writes zeros drags every salary average it feeds straight down.

### How to use it

#### Search by keyword and location

Set **Keywords** and **Locations**, pick a **Country market**, and run. Every keyword is combined with every location, so 3 keywords and 4 locations run 12 searches in one go.

```json
{
    "searchQueries": ["registered nurse", "nurse practitioner"],
    "locations": ["Boston, MA", "Providence, RI"],
    "market": "us",
    "maxItems": 500
}
```

Talent.com requires a location. A keyword with no location returns nothing, so the Actor stops with a clear message instead of handing you an empty run.

#### Scrape search URLs directly

Paste talent.com URLs into **Search URLs** in either form the site uses:

```json
{
    "startUrls": [
        "https://ca.talent.com/jobs?k=nurse&l=Toronto%2C+ON",
        "https://de.talent.com/jobs/k-krankenschwester-l-berlin"
    ],
    "maxItems": 200
}
```

The market is read from the URL, so you can mix countries in one run.

#### Full job descriptions

By default every row carries talent.com's 303-character description snippet and `descriptionIsTruncated: true`. Switch on **Fetch full descriptions** to open each job's own page and return the complete posting body plus its HTML. That costs one extra request per job so the run takes longer, but the price per job is unchanged.

Some postings have no description on talent.com at all. Those keep the snippet and stay flagged, rather than silently returning an empty string.

### Countries supported

United States, Canada, United Kingdom, Ireland, Australia, New Zealand, Germany, Austria, Switzerland, France, Belgium, Netherlands, Spain, Italy, Sweden, Poland, Mexico, Brazil, India, Singapore and South Africa.

Each market is a separate job index in its own language, so pick the market your locations belong to.

### How many jobs one search returns

Talent.com truncates every result set well before its index runs out. In testing, a city-level search returned about 68 jobs over 4 pages and a country-level search about 125 over 7 pages, at roughly 19 jobs per page.

This is a limit of the site, not of the Actor, and every talent.com scraper hits it. To collect thousands of jobs, run **many keyword and location combinations** rather than one broad search. Duplicate listings are removed across all searches in a run, so overlapping queries never bill you twice for the same job.

### Output

Results land in the default dataset, ready to export as JSON, CSV or Excel, or to pull through the Apify API in Python, JavaScript or any HTTP client. The Console shows a table view with the columns most people want first.

A run whose searches matched nothing still writes one row with `noResults: true` and a `message` explaining why, so an empty result is visible in your data pipeline instead of arriving as an empty file.

### Common uses

- **Recruiting and sourcing.** Pull live openings by role and metro, then reach employers through `applyUrl` and `sourceAts`.
- **Salary benchmarking.** `salaryMin`, `salaryMax`, `salaryPeriod` and `onetSocCode` give you banded pay data already mapped to official occupation codes.
- **Labour market research.** `latitude`, `longitude`, `datePosted` and `dateExpires` support geographic and time-series analysis of hiring demand.
- **Lead generation.** `sourceAts` reveals which applicant tracking system each employer runs, which is a strong buying signal for HR tech.
- **Job board aggregation.** Schedule the Actor and diff on `jobId` to track new and expired postings.

### Notes and limits

- Talent.com is tolerant of datacenter IPs, so the default shared Apify proxy is enough. Residential proxies work but cost far more and buy nothing here.
- `category`, `onetSocTitle` and `salaryAverage` are frequently empty in talent.com's own data. The Actor returns `null` rather than inventing a value.
- Talent.com falls back to broader results when a keyword matches nothing, so a very unusual keyword can return loosely related jobs. Check `searchKeyword` against `title` if precision matters.
- Data is scraped from publicly accessible pages. No account, cookie or session credential is required or accepted.

# Actor input Schema

## `searchQueries` (type: `array`):

Job titles or keywords to search, one per line. Leave empty to return everything hiring in the locations below. Each keyword is combined with each location, so 3 keywords and 2 locations run 6 searches.

## `locations` (type: `array`):

Where to search, one per line. Required: talent.com returns nothing for a keyword with no location. Accepts cities ("New York, NY"), regions ("Ontario") and whole countries ("United States"). Broader locations return more jobs per search.

## `market` (type: `string`):

Which talent.com country index to search. Each market is a separate job index with its own listings and language, so pick the one your locations belong to.

## `startUrls` (type: `array`):

Paste talent.com search URLs to scrape them directly, for example https://www.talent.com/jobs?k=nurse\&l=Toronto or https://ca.talent.com/jobs/k-nurse-l-toronto. Use this instead of the fields above when you already have the searches you want. Keywords, locations and market are ignored for these URLs.

## `maxItems` (type: `integer`):

Hard cap on jobs returned across all searches, and the cap on what you are charged. Note that talent.com truncates each search at roughly 70 to 125 jobs, so reaching a large number needs several keyword and location combinations rather than one broad search.

## `maxPagesPerQuery` (type: `integer`):

How deep to page each individual search. talent.com serves about 19 jobs per page and stops returning results after 4 to 7 pages, so the default already reaches the site's own ceiling. Lower it to sample many searches cheaply.

## `fetchFullDescriptions` (type: `boolean`):

Off by default, every job still carries a 303-character description snippet. Turn this on to open each job's own page and return the complete posting body instead. It costs one extra request per job, so a run takes noticeably longer, but you are charged the same per job. Every row tells you which it got through the descriptionIsTruncated field.

## `proxyConfiguration` (type: `object`):

talent.com does not block datacenter IPs, so the default shared Apify proxy is enough. Residential proxies work but cost far more and buy nothing here.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer"
  ],
  "locations": [
    "New York, NY"
  ],
  "market": "us",
  "startUrls": [],
  "maxItems": 100,
  "maxPagesPerQuery": 12,
  "fetchFullDescriptions": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

Every job listing collected in this run, as JSON.

## `jobsCsv` (type: `string`):

The same job listings as a CSV download.

## `jobsExcel` (type: `string`):

The same job listings as an Excel workbook.

# 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 = {
    "searchQueries": [
        "software engineer"
    ],
    "locations": [
        "New York, NY"
    ],
    "market": "us",
    "maxItems": 100,
    "maxPagesPerQuery": 12,
    "fetchFullDescriptions": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/talent-com-jobs-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 = {
    "searchQueries": ["software engineer"],
    "locations": ["New York, NY"],
    "market": "us",
    "maxItems": 100,
    "maxPagesPerQuery": 12,
    "fetchFullDescriptions": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/talent-com-jobs-scraper").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 '{
  "searchQueries": [
    "software engineer"
  ],
  "locations": [
    "New York, NY"
  ],
  "market": "us",
  "maxItems": 100,
  "maxPagesPerQuery": 12,
  "fetchFullDescriptions": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cirkit/talent-com-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cirkit/talent-com-jobs-scraper"
        }
    }
}

```

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/NJuq4pozRYonv2hHX/builds/IvVYxeyDj8JFriQ9B/openapi.json