# Job Search (`truefetch/job-search`) Actor

Job Search is a job search API for 42 sources that returns 41 normalized job, salary, company, application, and public contact fields. One input can combine compatible sources for the selected country.

- **URL**: https://apify.com/truefetch/job-search.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 1,043 total users, 19 monthly users, 100.0% runs succeeded, 26 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.38 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Search

**Job Search is a job search api that queries up to 42 compatible job sources and returns 41 normalized job, salary, company, application, and public contact fields, built for developers and data teams.**

- **42 job platforms available through one input.**
- **98 selectable countries.**
- **10 public inputs with 3 required.**
- **41 normalized Dataset fields.**

[**Run a one-result test**](https://apify.com/truefetch/job-search) · [**View API**](https://apify.com/truefetch/job-search/api)

Set `max_results` to `1`; the smallest published-result test bills a minimum $0.01000 Actor Start plus one $0.00450 Result, or $0.01450 on FREE.

### What does Job Search do?

Job Search collects public listings from multiple job boards through one input and one 41-field output contract. Provide a keyword, country, and per-platform result limit, then select compatible sources. Every item retains its source identity.

The Actor helps developers and data teams avoid separate board-specific pipelines. It can return role, location, salary, company, application, and public contact fields when the source publishes them.

Job Search is independent of the listed platforms and is not an auto-apply, candidate-database, or applicant-tracking service. Each platform controls its inventory, relevance, filters, and optional fields; LinkedIn's [official job-search guide](https://www.linkedin.com/help/linkedin/answer/a511260/applying-for-a-job-on-linkedin?lang=en) illustrates those source-specific search semantics.

### How do I run Job Search?

1. Open [Job Search on Apify](https://apify.com/truefetch/job-search).
2. Enter the three required inputs: `keyword`, `country`, and `max_results`.
3. For the lowest-risk first run, select one platform and set `max_results` to `1`.
4. Click **Start**, inspect the Dataset item, and scale only after the fields fit your workflow.

This runnable example uses one consistent scenario throughout the README: find up to one remote Data Analyst listing from Indeed in the United States, posted within the last seven days.

```json
{
  "keyword": "Data Analyst",
  "country": "United States",
  "platforms": ["Indeed"],
  "max_results": 1,
  "remote_only": true,
  "posted_since": "7 days",
  "job_type": "fulltime",
  "currency": "USD"
}
```

`max_results` is a limit per platform, not a total for the entire run. If you later select three platforms with `max_results: 10`, the run can publish up to 10 results from each platform, subject to availability.

### What data does Job Search return?

The default Dataset contains **41 fields**. Every item uses the same top-level field names, while values that a source or employer does not publish remain empty instead of being guessed.

| Field group | Fields |
| --- | --- |
| Processing | `processor`, `processed_at` |
| Source and application | `platform`, `platform_url`, `official_url`, `easy_apply` |
| Role details | `title`, `description`, `job_type`, `job_level`, `job_function`, `listing_type`, `skills`, `experience_range` |
| Location and work mode | `location`, `is_remote`, `work_mode` |
| Dates and volume | `posted_date`, `valid_through`, `applicant_count`, `vacancy_count` |
| Compensation | `salary_minimum`, `salary_maximum`, `salary_currency`, `salary_period` |
| Company | `company_name`, `company_type`, `company_founded`, `company_industry`, `company_url`, `company_website`, `company_logo`, `company_addresses`, `company_revenue`, `company_description`, `company_rating`, `employee_count`, `review_count` |
| Public contacts | `emails`, `phones`, `social_links` |

This abbreviated, illustrative item matches the one-result Data Analyst scenario above:

```json
{
  "platform": "Indeed",
  "platform_url": "https://www.indeed.com/viewjob?jk=example123",
  "official_url": "https://careers.example.com/jobs/data-analyst",
  "title": "Data Analyst",
  "company_name": "Example Analytics",
  "location": {
    "raw": "Remote, United States",
    "locality": null,
    "region": null,
    "country": "United States",
    "countryCode": "US"
  },
  "is_remote": true,
  "salary_minimum": 85000,
  "salary_maximum": 105000,
  "salary_currency": "USD",
  "posted_date": "2026-07-18",
  "emails": [],
  "phones": [],
  "processor": "https://apify.com/truefetch/job-search",
  "processed_at": "2026-07-20T12:00:00.000Z"
}
```

See the live [Output schema](https://apify.com/truefetch/job-search/output-schema) for field types and examples.

### What inputs can I configure?

Job Search exposes 10 public inputs in schema order, with 3 required and the rest optional.

| Parameter | Type | Required | Description | Example |
| --- | --- | :---: | --- | --- |
| `max_results` | integer | Yes | Maximum normalized listings to return from each available source. | `4` |
| `keyword` | string | Yes | Job title, skill, or company query for the available sources. | `Data Analyst` |
| `country` | select | Yes | Country used to choose compatible sources and regional endpoints. | `Canada` |
| `location` | string | No | City, area, or postal code for the compatible sources. | — |
| `platforms` | array | No | Available job sources to include in one normalized search. | — |
| `posted_since` | date | No | Earliest posting date where an available source accepts the filter. | — |
| `remote_only` | boolean | No | Return remote roles where an available source accepts the filter. | — |
| `distance` | integer | No | Radius in miles around the location where an available source accepts it. | — |
| `job_type` | select | No | Employment type where an available source accepts the filter. | — |
| `currency` | select | No | Target currency for normalized salary conversion when amounts are available. | — |

`country` has 98 accepted values; `platforms` has 42 accepted values; `job_type` has 5 accepted values; `currency` has 166 accepted values. Optional fields have no request effect when omitted; use the [live Input schema](https://apify.com/truefetch/job-search/input-schema) for types and accepted values.

### What platforms and markets does Job Search cover?

One country-aware request can select one or more compatible job sources.

The public input exposes 42 platform choices and 98 country choices. Compatibility depends on the selected country, so use the [live Input schema](https://apify.com/truefetch/job-search/input-schema) for the current accepted values.

Coverage states where the Actor can form a request; live inventory, relevance, language, and optional field availability still come from the selected public source.

### Why use Job Search?

| Capability | Practical benefit |
| --- | --- |
| One multi-board input | Reuse the same search contract instead of preparing a separate request for every source. |
| One normalized 41-field dataset | Load records into analytics, data products, ATS-adjacent workflows, or AI systems with less remapping. |
| Source attribution | Audit every item through `platform`, `platform_url`, and, when available, `official_url`. |
| Country-aware coverage | Search appropriate boards for each selected market rather than assuming every board is global. |
| Controlled first run | Test one platform and one result before increasing platform count or volume. |
| Apify delivery | Use Datasets, exports, schedules, webhooks, API calls, or MCP after the same initial configuration. |

The main trade-off is source variation. A normalized schema makes records easier to consume, but it cannot make every platform expose the same filters or fields.

### Who is Job Search for?

| Team | Typical use |
| --- | --- |
| Developers | Add multi-board job search to an application, alerting service, or internal tool. |
| Data engineers | Collect source-attributed job records for a warehouse or repeatable pipeline. |
| Analytics and research teams | Compare demand, salary, work mode, skills, and hiring activity across markets. |
| Job-board product teams | Build search, newsletters, monitoring, or niche vacancy products from normalized listings. |
| Recruiting and market intelligence | Monitor public hiring activity across selected companies, platforms, or countries. |

It is a poor fit for guaranteed optional fields, source-exclusive features, automated applications, or a complete historical database.

### How can I use Job Search through the API or MCP?

The public Actor ID is **`8QfidRKcSVYICkwrq`**; the name form **`truefetch/job-search`** is also accepted. Always start runs asynchronously: a broad multi-source search takes 5–10 minutes, and Apify's synchronous `run-sync-get-dataset-items` endpoint cuts the HTTP connection after 300 seconds without stopping the run — a client that times out and retries creates duplicate billed runs, while the asynchronous flow below returns immediately and can never produce duplicates.

#### Run the Actor with HTTP

Start the run with the same one-result Data Analyst scenario. The response arrives immediately and contains `data.id` (the run ID) and `data.defaultDatasetId` (the Dataset ID):

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/8QfidRKcSVYICkwrq/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "Data Analyst",
    "country": "United States",
    "platforms": ["Indeed"],
    "max_results": 1,
    "remote_only": true,
    "posted_since": "7 days",
    "job_type": "fulltime",
    "currency": "USD"
  }'
```

Poll the run every 30 seconds until `data.status` is `SUCCEEDED`, replacing `RUN_ID` with the `data.id` value from the start response — or skip polling by registering a webhook for the `ACTOR.RUN.SUCCEEDED` event:

```bash
curl "https://api.apify.com/v2/actor-runs/RUN_ID?token=$APIFY_TOKEN"
```

Fetch the results, replacing `DATASET_ID` with the `data.defaultDatasetId` value from the start response. The Actor pushes jobs to the Dataset in real time, so this call also returns partial results while the run is still in progress:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=$APIFY_TOKEN"
```

#### Connect the Actor through MCP

This Streamable HTTP configuration follows the current [Apify MCP documentation](https://docs.apify.com/integrations/mcp). Replace the token placeholder with your Apify API token.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=truefetch/job-search",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

After connecting, use the same scenario in natural language: “Find up to one remote Data Analyst job from Indeed in the United States, posted within the last seven days, and return salary, company, and application fields.”

For asynchronous runs, SDK examples, OpenAPI, and generated snippets, use the [Job Search API page](https://apify.com/truefetch/job-search/api).

### How much does Job Search cost?

Job Search costs $0.00450 per Result on FREE plus $0.01000 per minimum Actor Start event, so the smallest one-result test totals $0.01450.

| Apify tier | Actor Start | Per Result |
| --- | ---: | ---: |
| FREE | $0.01000 | $0.00450 |
| BRONZE | $0.01000 | $0.00405 |
| SILVER | $0.01000 | $0.00360 |
| GOLD | $0.01000 | $0.00338 |
| PLATINUM | $0.01000 | $0.00338 |
| DIAMOND | $0.01000 | $0.00338 |

Result is billed once for each item written to the default Dataset. Actor Start event count depends on selected memory, with a minimum of one event.

Smallest useful test: $0.01000 + 1 × $0.00450 = **$0.01450** on FREE when one item is published. A zero-result run can still incur Actor Start. [Prices can change; check live pricing](https://apify.com/truefetch/job-search/pricing) before scheduling volume.

### How does Job Search compare with alternatives?

| Decision factor | Job Search | Single-board Actor | Separate source integrations |
| --- | --- | --- | --- |
| Coverage | 42 platforms and 98 selectable countries | One platform's supported markets | Whatever the team builds and maintains |
| Output | One normalized 41-field schema | Source-focused schema | A team-defined schema and mapping layer |
| First test | One platform and one result can be tested | Usually a narrow source test | Requires each integration to be ready |
| Source depth | Common normalized fields across boards | Better fit for board-specific requirements | Highest potential customization |
| Operations | One Actor, Dataset, API, and MCP surface | One Actor per selected source | Separate maintenance for each source |
| Best fit | Multi-market, multi-board job data | One known source is sufficient | Bespoke control justifies ongoing ownership |

Choose Job Search when breadth, repeatability, and a shared dataset matter most. Choose a related single-board TrueFetch Actor when you only need one source. Build separate integrations when source-specific behavior is more important than the time and cost of owning them.

### What are the limits and troubleshooting steps?

| Symptom or limit | Explanation | Next step |
| --- | --- | --- |
| More results than expected | `max_results` applies per platform. | Reduce the limit, platform count, or both. |
| Results feel loosely related | Relevance follows each source board's search behavior. | Use a more specific title, skill, or employer and split mixed intents into separate runs. |
| A filter appears ineffective | Platforms differ in location, recency, remote, distance, and job-type support. | Test one source at a time and remove unsupported assumptions. |
| Some fields are empty | Sources and employers publish different information. | Make salary, company, applicant, and contact fields nullable downstream. |
| The same vacancy appears twice | A job can be published on multiple boards. | Deduplicate with URLs plus company, title, and location when needed. |
| One platform returns nothing or fails | Multi-platform runs can provide partial source coverage. | Review the run, retry the affected platform separately, and keep successful source-attributed results. |
| Salary is not converted | Numeric salary and a usable source currency are required. | Do not infer missing compensation; compare only populated salary records. |

Before reporting a problem, rerun the smallest reproducible input: one specific keyword, one country, one platform, and `max_results: 1`. Include the run URL and the expected platform when opening an [Apify Issue](https://apify.com/truefetch/job-search/issues); do not include API tokens or private data.

### Frequently asked questions

#### Can I use job search api without separate job board keys?

Yes. Job Search runs on Apify without asking for a source-site publisher credential; an Apify account and token are still required for authenticated API or MCP calls.

#### What does “multi source job listings api” mean for this Actor?

Set `keyword`, `country`, and `max_results`, then add only the optional fields present in this Actor's input table. Results are capped by source availability and relevance.

#### Does Job Search require a source-site login?

No source-site username, password, cookie, or API key appears in the public input. The Actor collects accessible public listings independently of the source.

#### Why are salary, company, applicant, or contact values empty?

Those values are nullable because public listings do not expose the same detail. Empty means unavailable from the collected source, not zero or false.

#### Is there a free jobs API?

Apify accounts include platform usage under the current Apify plan, while this Actor bills Actor Start and Result events. Use the one-result calculation in Pricing to evaluate the smallest test.

#### Can I schedule runs to monitor multi-source job listings over time?

Yes. Test a small input first, then use Apify schedules and webhooks. Preserve `processed_at` and source URLs because listings can change, close, or reappear.

#### How is billing counted for Job Search?

Billing uses Actor Start events and one Result event per default Dataset item. A requested result limit is a cap, not a prepaid bundle or a guarantee of source inventory.

### Related TrueFetch Actors

Job Search has three nearby TrueFetch alternatives, each for a different source decision.

- [Indeed Job Listing](https://apify.com/truefetch/indeed-job-listing) — Use it for an Indeed-only contract and Indeed market filters.
- [LinkedIn Job Listing](https://apify.com/truefetch/linkedin-job-listing) — Use it for LinkedIn-specific role and applicant signals.
- [Glassdoor Job Listing](https://apify.com/truefetch/glassdoor-job-listing) — Use it for Glassdoor salary and employer-rating context.

### Support

Use the [Store page](https://apify.com/truefetch/job-search) for the run interface, the [API page](https://apify.com/truefetch/job-search/api) for generated clients, [Issues](https://apify.com/truefetch/job-search/issues) for reproducible bugs, and the [TrueFetch community](https://t.me/TrueFetch) for usage questions.

[**Run a one-result test**](https://apify.com/truefetch/job-search) · [**View API**](https://apify.com/truefetch/job-search/api)

**Last Updated:** August 31, 2026

# Actor input Schema

## `max_results` (type: `integer`):

Maximum job rows to return from each selected job source

## `keyword` (type: `string`):

Job title, skill, or company query to search across selected job sources

## `country` (type: `string`):

Country used to choose compatible job sources and regional endpoints

## `location` (type: `string`):

Optional city, area, or postal code sent only to job sources that support location

## `platforms` (type: `array`):

Optional job sources to search; leave empty to use every compatible source for the country

## `posted_since` (type: `string`):

Optional earliest posting date applied only by job sources that support it

## `remote_only` (type: `boolean`):

Optional remote-only filter applied only by job sources that support it

## `distance` (type: `integer`):

Optional search radius in miles applied only by job sources that support it

## `job_type` (type: `string`):

Optional employment type applied only by job sources that support it; `all` disables this filter

## `currency` (type: `string`):

Optional target currency for normalized salary conversion across selected job sources

## Actor input object example

```json
{
  "max_results": 4,
  "keyword": "Data Analyst",
  "country": "Canada"
}
```

# Actor output Schema

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

Default dataset overview of normalized job listings and company fields collected by All Jobs Scraper.

# 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 = {
    "max_results": 4,
    "keyword": "Data Analyst",
    "country": "Canada"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/job-search").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 = {
    "max_results": 4,
    "keyword": "Data Analyst",
    "country": "Canada",
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/job-search").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 '{
  "max_results": 4,
  "keyword": "Data Analyst",
  "country": "Canada"
}' |
apify call truefetch/job-search --silent --output-dataset

```

## MCP server setup

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

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/8QfidRKcSVYICkwrq/builds/oI3CJFK4M1ku3nuuG/openapi.json