# Talent.com Job Scraper – Real-Time Data (`b2b_leads/talent-real-time-data-scraper`) Actor

Collect live Talent.com job listings in real time: keyword + location search, company watchlists, full detail enrichment with salary ranges, and direct URL lookup. Records stream to your dataset and webhooks as collected.

- **URL**: https://apify.com/b2b_leads/talent-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 results

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

## Talent Real-Time Data

Collect live job listings from Talent.com in real time — keyword search, company watchlists, full detail enrichment, and direct URL lookup. Every record streams to your dataset as it is collected, and can also be pushed to a webhook the moment it is finalized.

> **Free trial:** on the Apify free plan each run returns a 2-result sample. Upgrade to a paid Apify plan for full, unlimited data.

### Who it is for

- **Recruiters & sourcers** building pipeline from fresh postings by role and location
- **Staffing agencies** monitoring new openings at target accounts
- **Job-board & career-site operators** keeping listings fresh against the source
- **Labor-market researchers** tracking hiring demand, titles, and salary ranges
- **Sales teams** prospecting companies that are actively hiring
- **AI agents** that need structured, up-to-date job data on demand

### Features

| Feature | What it does | Default |
|---|---|---|
| 💼 Job search | Search live listings by keyword + location; fast cards with title, company, location, salary, snippet, posting age | On (10 per search) |
| ✨ Fetch full details | Enriches each row in place with full description, salary range, employment type, posting date | Off |
| 🏢 Company jobs | Openings at named companies (one search per company) | Off |
| 🔗 Scrape by URL | Full rows from explicit Talent.com job links | Off |
| 📣 Webhook delivery | Extra real-time push of every record (JSON or Slack) | Off |

Enrichment never drops rows: every discovered job is exported, with `detailsFetched: true` when full details were added.

### Input reference

| Field | Type | Default | Example |
|---|---|---|---|
| `enableJobSearch` | checkbox | `true` | — |
| `jobKeywords` | string list | `["software engineer"]` | `["registered nurse", "warehouse associate"]` |
| `jobLocation` | text | `"United States"` | `"New York, NY"`, `"Remote"` |
| `jobsPerQuery` | number | `10` | `50` |
| `fetchFullDetails` | checkbox | `false` | `true` for descriptions + salary ranges |
| `enableCompanyJobs` | checkbox | `false` | — |
| `companyNames` | string list | `[]` | `["Amazon", "Tesla"]` |
| `jobsPerCompany` | number | `10` | `25` |
| `enableScrapeByUrl` | checkbox | `false` | — |
| `jobUrls` | string list | `[]` | `["https://www.talent.com/view?id=626159695573821803"]` |
| `webhookUrl` | text | `""` | Slack incoming webhook or Zapier URL |
| `webhookFormat` | select | `"json"` | `"slack"` for chat-friendly messages |
| `proxyConfiguration` | proxy | Residential / US | — |

Leave everything untouched and press Start: the demo searches “software engineer” in the United States and returns 10 jobs in seconds.

### Output fields

Each dataset row is one job: `featureType`, `jobId`, `title`, `company`, `companyLogo`, `location`, `salary`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `snippet`, `postedAt`, `postedText`, `employmentType`, `descriptionText` (with full details on), `detailsFetched`, `jobUrl`, `searchQuery`, `searchLocation`, `position`, `source`, `scrapedAt`.

The run `OUTPUT` record summarizes `totalPushed`, `enabledFeatures`, `errors`, `spendingLimitReached`, and the `paywall` gate state.

### Webhooks

Set `webhookUrl` to receive every record twice: once in the dataset (always), once as a POST to your URL. Choose `json` for the raw record or `slack` for a ready-to-read chat message. Delivery is fire-and-forget — a failing webhook never stops the run.

### AI-agent usage (MCP)

Pair this Actor with the Apify MCP server, then ask things like:

> “Find the 20 newest software engineer jobs in Austin on Talent.com with salary info, and send them to my webhook.”

The agent maps your question onto `jobKeywords`, `jobLocation`, `jobsPerQuery`, and `fetchFullDetails` automatically.

### FAQ

**How fresh is the data?** Every run collects the listings shown on Talent.com right now — nothing is cached or pre-stored.

**Which proxy should I use?** The default Apify residential proxy (US) works out of the box and gives the freshest results.

**Why did a free-plan run return only 2 results?** That is the free-trial sample. Upgrade to a paid Apify plan for full, unlimited data.

**Do I pay per result?** The Actor charges one `result` pay-per-event credit per exported job. The `jobsPerQuery` / `jobsPerCompany` caps are your cost levers, and runs always respect your spending limit gracefully.

**A run returned fewer rows than my cap — is something wrong?** Usually not: some searches simply have fewer matching listings, and detail enrichment never filters rows out. Re-run later or widen the keywords.

# Actor input Schema

## `enableJobSearch` (type: `boolean`):

Search live Talent.com listings by keyword and location. Returns fast cards: title, company, location, salary when shown, snippet, and posting age. On by default.

## `jobKeywords` (type: `array`):

Keywords for the Talent.com search box, e.g. "software engineer", "registered nurse", "warehouse associate". One search runs per keyword.

## `jobLocation` (type: `string`):

Location to search in, e.g. "United States", "New York, NY", "Remote". Leave empty to search everywhere.

## `jobsPerQuery` (type: `integer`):

Cap the number of jobs collected per keyword search. This is the main cost lever for job search.

## `fetchFullDetails` (type: `boolean`):

Enrich each job row in place with its full description, salary range, employment type, and posting date. Every job is still exported even when details are unavailable (nothing is dropped). Adds a little extra time per record.

## `enableCompanyJobs` (type: `boolean`):

Collect live openings at specific companies by name, e.g. "Amazon", "Tesla". Runs one Talent.com search per company. Off by default — turn on and add company names.

## `companyNames` (type: `array`):

Company names to collect openings for (only used when Company jobs is enabled).

## `jobsPerCompany` (type: `integer`):

Cap the number of jobs collected per company.

## `enableScrapeByUrl` (type: `boolean`):

Collect full job records from explicit Talent.com job URLs (talent.com/view?id=...). Off by default — turn on and paste URLs.

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

Talent.com job page URLs to collect (only used when Scrape by URL is enabled).

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new record is also delivered to this URL (CRM, Slack incoming webhook, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

Payload format for the webhook push: raw JSON record, or a Slack-friendly message.

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

Proxy for Talent.com collection. Residential US proxies are recommended for the freshest results.

## Actor input object example

```json
{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer"
  ],
  "jobLocation": "United States",
  "jobsPerQuery": 10,
  "fetchFullDetails": false,
  "enableCompanyJobs": false,
  "companyNames": [],
  "jobsPerCompany": 10,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every job field from all enabled features in this run.

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

Job rows from job search, company jobs, and scrape-by-URL.

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

Per-run metadata: enabled features, exported record count, non-fatal errors, spending-limit status, and the paywall object (detected, isPaying, pricingTier, blocked, limited).

# 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 = {
    "enableJobSearch": true,
    "jobKeywords": [
        "software engineer"
    ],
    "jobLocation": "United States",
    "jobsPerQuery": 10,
    "fetchFullDetails": false,
    "enableCompanyJobs": false,
    "jobsPerCompany": 10,
    "enableScrapeByUrl": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/talent-real-time-data-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 = {
    "enableJobSearch": True,
    "jobKeywords": ["software engineer"],
    "jobLocation": "United States",
    "jobsPerQuery": 10,
    "fetchFullDetails": False,
    "enableCompanyJobs": False,
    "jobsPerCompany": 10,
    "enableScrapeByUrl": False,
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/talent-real-time-data-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 '{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer"
  ],
  "jobLocation": "United States",
  "jobsPerQuery": 10,
  "fetchFullDetails": false,
  "enableCompanyJobs": false,
  "jobsPerCompany": 10,
  "enableScrapeByUrl": false
}' |
apify call b2b_leads/talent-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/talent-real-time-data-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/9E3eNsKduovXDEMoE/builds/MvtJU6m2NKHCJ4qXF/openapi.json