# Job Scraper - LinkedIn, Indeed, Glassdoor, Google Jobs & More (`vero-api/jobs-scraper`) Actor

Search LinkedIn, Indeed, Glassdoor, Bayt, Naukri and BDJobs at once and get one de-duplicated spreadsheet of jobs: salaries, company profiles, apply links and full descriptions. Filter by company, radius, date and job type. Works with AI agents.

- **URL**: https://apify.com/vero-api/jobs-scraper.md
- **Developed by:** [VeroAPIs](https://apify.com/vero-api) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 373 total users, 33 monthly users, 99.5% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 1,000 job listings

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 Scraper — LinkedIn Jobs, Indeed, Glassdoor, Bayt, Naukri & BDJobs in One Run

Search **LinkedIn, Indeed, Glassdoor, Bayt, Naukri and BDJobs** together and get **one clean, de-duplicated table**: title, company, location, salary, job type, company profile and the full description, one flat row per job. Download it as **CSV, Excel, JSON** or XML. Nothing to install and no account to connect: type a search and click Start.

One actor replaces three: it's a **LinkedIn jobs scraper, an Indeed scraper and a Glassdoor scraper** that all answer the same search and land in the same table. A default run of 60 jobs from three boards finishes in about 10 to 30 seconds.

### What you can do

- **Search LinkedIn, Indeed and Glassdoor at once** and get one spreadsheet instead of three browser tabs.
- **Cover 80 countries**, from the United States and Germany to the UAE, India and Bangladesh.
- **Run several searches and cities in one go**: up to 5 search terms in up to 10 locations, and every job shows which term and location brought it in.
- **Target companies on LinkedIn**: get jobs from Google, Amazon or any company by its LinkedIn company ID.
- **Set your search radius**: from the city itself out to 200 miles on LinkedIn and Indeed.
- **Get full job details** by default: complete descriptions, seniority, employment type, skills, benefits, apply links and company profiles (industry, size, revenue, website, rating).
- **Filter before you pay**: job type, remote only, easy apply and posting date are applied on the boards themselves.
- **Drop duplicates** of the same role posted on several boards.

### Use cases

- **Talent sourcing**: see every opening for a role in your city across the big boards, then reach out to the companies behind them.
- **Prospect lists from hiring signals**: companies that post jobs have budget and are growing. Pull their industry, size, revenue and website straight from the listings.
- **Job board content**: fill a niche or regional job site with fresh postings on a daily schedule.
- **Pay and demand research**: compare salary ranges, remote share and the skills employers ask for, city by city or country by country.
- **Personal job alerts**: run a daily search for the roles you want and get only the new ones in a spreadsheet, email or Slack.
- **Live data for AI**: let an assistant or LLM app look up current openings on request through MCP or the API.

### How to use it

1. **Say what you want**: enter *Search keywords*, pick a *Country*, and optionally a *Location* inside it.
2. **Pick your boards**: any of LinkedIn, Indeed, Glassdoor, Bayt, Naukri and BDJobs.
3. **Narrow it down** *(optional)*: posting date, job type, remote, easy apply, search radius, LinkedIn companies.
4. **Set how many**: *Max results per board* controls how many jobs each board returns for each search.
5. **Click Start**, then download your results as CSV, Excel or JSON from the **Output** tab, or send them anywhere with integrations.

> Want several queries at once? Add them under **Multiple search terms** and **Multiple locations**. Every term runs in every location, results are merged and de-duplicated, and each job records the term and location that found it.

#### Choosing boards

Most boards are global, and a few are regional. Pick the ones that fit your market:

- **LinkedIn, Indeed, Glassdoor**: global. **Country** picks the country they search; leave **Location** empty to search the whole country, or type a city or region inside it.
- **Bayt**: the Middle East. **Naukri**: the Gulf and the Middle East. Both search the selected **Country**, so pick a Gulf or Middle East country for them.
- **BDJobs**: Bangladesh. It has its own **BDJobs market** field: Bangladesh by default, or one of the overseas markets BDJobs lists jobs for (Saudi Arabia, UAE, Qatar, Malaysia and more).

### What you get

Every job is **one flat row** with the same columns whichever board it came from, so a CSV or Excel export is ready to filter and sort straight away.

| Column | What it holds |
|---|---|
| `id`, `site` | Unique job ID and the board it came from |
| `title`, `company` | Job title and hiring company |
| `location`, `location_city`, `location_state`, `location_country` | Where the job is, as one line and split into parts |
| `job_url`, `job_url_direct` | The posting on the board and the direct apply link |
| `job_type`, `is_remote`, `date_posted` | Employment type, remote flag, posting date |
| `salary_min`, `salary_max`, `salary_currency`, `salary_interval`, `salary_source` | Pay range, listed by the board (`direct_data`) or read from the description (`description`) |
| `job_level`, `job_function`, `listing_type` | Seniority, job category, sponsored or not |
| `company_industry`, `company_num_employees`, `company_revenue` | Company profile |
| `company_url`, `company_url_direct`, `company_logo`, `banner_photo_url` | Company page on the board, company website, images |
| `company_addresses`, `company_description`, `company_ceo` | Headquarters, about the company, CEO |
| `company_rating`, `company_reviews_count` | Employee rating and number of reviews (Glassdoor) |
| `description` | The full job description in Markdown, HTML or plain text |
| `emails`, `skills`, `benefits`, `experience_range` | Contact emails found in the description, skill tags, perks, experience asked for |
| `search_term`, `matched_search_term`, `matched_location` | The run's search terms, and the term and location that found this job |
| `scraped_at` | When the job was collected |

The Output tab also gives you ready-made **Overview**, **Companies** and **Salaries** views.

#### Output example

```json
{
    "id": "indeed-620a09117e853bdf",
    "site": "indeed",
    "title": "Senior Software Engineer",
    "company": "Example Corp",
    "location": "New York, NY, United States",
    "location_city": "New York",
    "location_state": "NY",
    "location_country": "United States",
    "job_url": "https://www.indeed.com/viewjob?jk=620a09117e853bdf",
    "job_url_direct": "https://careers.example.com/job/12345",
    "job_type": "Full-time",
    "is_remote": false,
    "date_posted": "2026-11-02",
    "salary_source": "direct_data",
    "salary_min": 165000,
    "salary_max": 210000,
    "salary_currency": "USD",
    "salary_interval": "yearly",
    "job_level": null,
    "job_function": null,
    "listing_type": null,
    "company_industry": "Software Development",
    "company_url": "https://www.indeed.com/cmp/Example-Corp",
    "company_url_direct": "https://www.example.com",
    "company_addresses": "350 5th Ave, New York, NY",
    "company_description": "Example Corp builds payroll software for small businesses.",
    "company_num_employees": "1,000 to 5,000",
    "company_revenue": "more than $1B (USD)",
    "company_rating": null,
    "company_reviews_count": null,
    "company_logo": "https://d2q79iu7y748jz.cloudfront.net/s/_squarelogo/example.png",
    "banner_photo_url": "https://d2q79iu7y748jz.cloudfront.net/s/_headerimage/example.png",
    "company_ceo": "Jane Doe",
    "description": "## About the role\nWe're hiring a senior engineer to build our payroll platform…",
    "emails": "careers@example.com",
    "skills": "Python, AWS, Kubernetes",
    "benefits": "Health insurance, 401(k)",
    "experience_range": null,
    "search_term": "software engineer, backend engineer",
    "matched_search_term": "software engineer",
    "matched_location": "New York, NY",
    "scraped_at": "2026-11-08T10:15:32.412Z"
}
```

Columns a board doesn't provide come back empty: for example, `company_rating` and `company_reviews_count` come from Glassdoor, and `job_level` from LinkedIn and Bayt.

### Input examples

A focused search with filters:

```json
{
    "searchTerm": "registered nurse",
    "country": "us",
    "location": "Austin, TX",
    "distance": 25,
    "sites": ["linkedin", "indeed", "glassdoor"],
    "maxResults": 25,
    "hoursOld": 168,
    "jobType": "fulltime"
}
```

Several queries in several cities, remote only:

```json
{
    "searchTerms": ["AI engineer", "machine learning engineer"],
    "country": "us",
    "locations": ["San Francisco, CA", "New York, NY"],
    "sites": ["linkedin", "indeed"],
    "maxResults": 50,
    "isRemote": true
}
```

Jobs from specific companies on LinkedIn (Google and Amazon Web Services):

```json
{
    "searchTerm": "engineer",
    "country": "us",
    "location": "New York, NY",
    "sites": ["linkedin"],
    "linkedinCompanyIds": ["1441", "2382910"],
    "maxResults": 100
}
```

The Gulf, with the regional boards:

```json
{
    "searchTerms": ["accountant", "محاسب"],
    "country": "ae",
    "location": "Dubai",
    "sites": ["bayt", "naukri", "linkedin"],
    "maxResults": 20
}
```

Salaries compared across boards, all converted to yearly pay:

```json
{
    "searchTerm": "data engineer",
    "country": "gb",
    "location": "London",
    "sites": ["linkedin", "indeed", "glassdoor"],
    "maxResults": 100,
    "enforceAnnualSalary": true
}
```

### Input reference

| Field | Type | Description |
|---|---|---|
| `searchTerm` | string | Job title, skill or company to search for. |
| `searchTerms` | array | Up to 5 queries to run in one go (merged and de-duplicated). Replaces `searchTerm`. |
| `country` | string | Country to search, as a 2-letter code from the list (for example `us`, `de`, `ae`). Default `us`. |
| `location` | string | City, state or region inside the selected country. Empty searches the whole country. |
| `locations` | array | Up to 10 locations to search in one go. Replaces `location`. |
| `distance` | integer | Search radius around the location in miles (LinkedIn, Indeed), 0 to 200. Default `50`. |
| `linkedinCompanyIds` | array | LinkedIn company IDs, for example `1441` for Google. LinkedIn then returns only those companies' jobs. |
| `sites` | array | Boards to search: `linkedin`, `indeed`, `glassdoor`, `bayt`, `naukri`, `bdjobs`. Default: LinkedIn, Indeed, Glassdoor. |
| `maxResults` | integer | Jobs per board for each search term and location (1 to 1000). Default `20`. |
| `jobType` | string | `fulltime`, `parttime`, `contract`, `internship` or `temporary` (LinkedIn, Indeed, Glassdoor, Bayt, BDJobs). Empty means any. |
| `hoursOld` | integer | Only jobs posted within the last N hours (LinkedIn, Indeed, Glassdoor, Bayt). |
| `isRemote` | boolean | Only remote roles. Default `false`. |
| `easyApply` | boolean | Only jobs you apply to on the board itself (LinkedIn, Indeed, Glassdoor, Naukri, Bayt). Default `false`. |
| `fetchExtraJobInfo` | boolean | Full job details: description, seniority, type, function, skills, benefits, apply link and company profile. Indeed always includes them. Default `true`. |
| `bdjobsCountry` | string | BDJobs market: `bd` (Bangladesh) or an overseas market code such as `sa`, `ae`, `qa`, `my`. Default `bd`. |
| `descriptionFormat` | string | `markdown`, `html` or `text`. Default `markdown`. |
| `offset` | integer | Skip the first N results, to continue an earlier run (LinkedIn, Glassdoor, Naukri, BDJobs, Bayt). |
| `enforceAnnualSalary` | boolean | Convert every salary to yearly pay (hourly × 2080, monthly × 12). Default `false`. |
| `deduplicate` | boolean | Keep each role once, within and across boards. Default `true`. |

### Pricing

You pay per job delivered, with no subscription and no monthly minimum. Jobs removed as duplicates are never charged.

| Your Apify plan | Price per 1,000 jobs |
|---|---|
| Free and Starter | $5.00 |
| Scale | $4.50 |
| Business and higher | $4.00 |

A tiny run-start fee of $0.00005 applies per run.

What typical runs cost on the Starter plan:

- A daily alert for one role on LinkedIn, Indeed and Glassdoor, 10 jobs each: up to 30 jobs, **$0.15**.
- One city, 5 related job titles, 3 boards, 50 jobs each: up to 750 jobs, **$3.75**.
- A country-wide salary study, 2 titles, 3 boards, 500 jobs each: up to 3,000 jobs, **$15.00**.

Your bill can never pass boards × search terms × locations × *Max results per board*, and duplicates bring it below that. Set a maximum cost per run in Apify Console if you want a hard limit: the run stops as soon as it's reached.

### Integrations

- **Spreadsheets and team tools**: new jobs can flow into Google Sheets, Airtable, Slack or your CRM after every run.
- **Automation platforms**: connect it to Zapier, Make or n8n and build any workflow around fresh job data.
- **Daily schedule**: set it to run each morning with **Posted within** at `24`, and a webhook can tell your own system the moment the jobs are ready.
- **HTTP**: everything in the Console is also available over Apify's REST API.

### Run it from your code or AI assistant

From JavaScript with the Apify client (`npm install apify-client`):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('vero-api/multi-job-board-scraper-linkedin-indeed-glassdoor-more').call({
    searchTerm: 'data analyst',
    country: 'gb',
    location: 'London',
    sites: ['linkedin', 'indeed', 'glassdoor'],
    maxResults: 50,
    hoursOld: 72,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'jobs');
```

From Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("vero-api/multi-job-board-scraper-linkedin-indeed-glassdoor-more").call(run_input={
    "searchTerms": ["product manager", "product owner"],
    "country": "de",
    "sites": ["linkedin", "indeed", "glassdoor"],
    "maxResults": 30,
})
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["site"], item["title"], item["company"], item["salary_min"])
```

Your token is under **Settings → API & Integrations** in Apify Console.

AI assistants such as Claude, ChatGPT and Cursor can run it too, through the Apify MCP server. Add this to your assistant's MCP settings:

```json
{
  "mcpServers": {
    "job-scraper": {
      "url": "https://mcp.apify.com?tools=vero-api/multi-job-board-scraper-linkedin-indeed-glassdoor-more"
    }
  }
}
```

Then just ask, for example:

- *"Show me data engineering jobs in Toronto from the last three days, with pay where it's listed."*
- *"Which companies are hiring accountants in Dubai right now?"*
- *"List Google's open engineering jobs in New York."*

### FAQ

**Can I use this as a jobs API?** Yes. Start a run over HTTP or with the Apify client and read the jobs back as JSON, or use `run-sync-get-dataset-items` to get them in a single call. You work with one API and one set of columns for every board, and there's nothing to apply for.

**What's the price per job?** Half a cent on the Free and Starter plans ($5.00 per 1,000), with lower rates on Scale ($4.50) and Business and higher ($4.00).

**How many jobs can I get?** Up to 1,000 per board for each search term and location. For example, 3 boards × 2 search terms × 50 results is up to 300 jobs in one run.

**How fast is it?** A default run of 60 jobs from three boards takes about 10 to 30 seconds, and jobs land in your dataset as each board delivers them.

**Which countries does it cover?** 80 countries. LinkedIn and Glassdoor search every one of them, Indeed searches the 62 countries where it has its own site, Bayt and Naukri focus on the Gulf and the Middle East, and BDJobs on Bangladesh and its overseas markets.

**How do I find a LinkedIn company ID?** Open the company's jobs on LinkedIn and look at the link: the number after `f_C=` is the ID (for example `1441` for Google). You can add several.

**Can I open the results in Excel or Google Sheets?** Yes. Every job is one flat row with simple columns such as `company`, `salary_min` and `job_url`, so the CSV and Excel exports open cleanly with no extra steps.

**What does Location do when I leave it empty?** LinkedIn, Indeed and Glassdoor search the whole selected country.

**Do filters cost me anything?** No. On LinkedIn, Indeed, Glassdoor and Bayt, job type, remote, easy apply and posting date are applied by the boards themselves, so you only pay for jobs that match. Naukri applies remote and easy apply, and BDJobs job type and remote.

**Why do I get fewer jobs than Max results?** That board had fewer matching jobs for your search, or some were removed as duplicates of jobs another board already returned. Try a broader term, fewer filters or more boards.

**How fresh are the jobs?** They're read live from each board when you run the scraper. Set **Posted within** to `24` to get only jobs from the last day.

**Can I get only new jobs every day?** Yes. Schedule the scraper daily with **Posted within** set to `24`, and use the job `id` to skip any you already have.

**Do I need an account, login or API key?** No. The scraper reads public job listings, the same ones anyone can browse.

**What formats can I download?** CSV, Excel, JSON, XML, RSS and HTML, or read the results through the Apify API.

**What data does it collect?** Only what a job board shows to every visitor: the posting and the employer's public profile. It never signs in and never touches personal accounts. If a posting includes a recruiter's email, treat it as personal data under your local privacy law (GDPR in Europe, for example).

**Is this an official LinkedIn, Indeed or Glassdoor tool?** No. This scraper is not affiliated with, endorsed by or sponsored by LinkedIn, Indeed, Glassdoor, Bayt, Naukri or BDJobs. It collects job listings that anyone can see on their websites.

### Notes

- Every board you pick is searched at the same time, so one run covers them all. A per-board summary (`RUN_SUMMARY`) is saved in the run's key-value store, and the run's status line shows how many jobs came from each board.
- The same role often appears on several boards, and several times on one. **Remove duplicates** (on by default) keeps the first copy by title, company and city.
- Each board returns the most when you search inside its home market: Bayt for the Middle East, Naukri for the Gulf and the Middle East, BDJobs for Bangladesh.

### More tools from us

- [LinkedIn Jobs Scraper](https://apify.com/vero-api/linkedin-jobs-scraper): LinkedIn job listings with full details.
- [Indeed Jobs Scraper](https://apify.com/vero-api/indeed-jobs-scraper): Indeed job listings with company profiles and salaries.
- [Google Jobs Scraper](https://apify.com/vero-api/google-jobs-scraper): jobs from Google's job search, which gathers postings from across the web.
- [Bayt Jobs Scraper](https://apify.com/vero-api/bayt-jobs-scraper): jobs across the Middle East.
- [Naukri Jobs Scraper](https://apify.com/vero-api/naukri-jobs-scraper): jobs across the Gulf.
- [BDJobs Scraper](https://apify.com/vero-api/bdjobs-jobs-scraper): jobs in Bangladesh and its overseas markets.

# Actor input Schema

## `searchTerm` (type: `string`):

Enter the job title, skill, or company you want, just as you would type it into a job board, for example software engineer or registered nurse. To run several searches at once, use Multiple search terms instead.

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

Pick the job boards to search. LinkedIn, Indeed and Glassdoor cover most countries. Bayt covers the Middle East, Naukri the Gulf and Middle East, and BDJobs Bangladesh and its overseas job markets.

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

Pick the country to search. LinkedIn, Indeed and Glassdoor search the whole country when Location is empty. Bayt and Naukri cover the Gulf and the Middle East best.

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

Enter a city, state or region inside the selected Country, for example Austin, TX or London. Leave empty to search the whole country. To search several places at once, use Multiple locations instead.

## `maxResults` (type: `integer`):

Set how many jobs you want from each board for each search (1 to 1000). Your total is about this number times the boards, search terms and locations you pick.

## `searchTerms` (type: `array`):

Add up to 5 searches to run in one go, for example AI engineer and machine learning engineer. Results are merged, and every job shows the term that found it. Leave empty to use Search keywords.

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

Add up to 10 cities or regions to search in one run, for example Austin, TX and Dallas, TX. Leave empty to use Location.

## `hoursOld` (type: `integer`):

Enter a number of hours to get only fresh jobs on LinkedIn, Indeed, Glassdoor and Bayt, for example 24 for the last day or 168 for the last week. Leave empty for any posting date.

## `jobType` (type: `string`):

Pick an employment type to get only those jobs on LinkedIn, Indeed, Glassdoor, Bayt and BDJobs. Leave as Any to get every type.

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

How far around your Location to look on LinkedIn and Indeed, in miles. Use 0 for the city itself only.

## `isRemote` (type: `boolean`):

Turn on to get only remote jobs.

## `easyApply` (type: `boolean`):

Turn on to get only jobs you can apply to directly on the job board (LinkedIn, Indeed, Glassdoor, Naukri and Bayt).

## `linkedinCompanyIds` (type: `array`):

Get LinkedIn jobs from these companies only, for example 1441 for Google and 2382910 for Amazon Web Services. Find a company's ID in the link of its jobs page on LinkedIn (f_C=1441). Leave empty to search every company.

## `bdjobsCountry` (type: `string`):

Pick which BDJobs listings to get when BDJobs is selected: jobs in Bangladesh, or jobs BDJobs lists for one of its overseas markets.

## `fetchExtraJobInfo` (type: `boolean`):

Keep on to get the full description and richer details for every job: seniority, employment type, job function, skills, benefits, apply links and company profile (industry, size, revenue, website). Turn off for faster runs with search-card data only.

## `descriptionFormat` (type: `string`):

Pick how job descriptions are written: Markdown is clean and readable, HTML keeps the original styling, and Plain text has no formatting at all.

## `enforceAnnualSalary` (type: `boolean`):

Turn on to convert every salary to a yearly figure (hourly x 2080, monthly x 12 and so on), so pay is easy to compare across jobs.

## `deduplicate` (type: `boolean`):

Keep on to get each role once, even when it is posted more than once or on several boards (same title, company and city). The first copy found is kept.

## `offset` (type: `integer`):

Enter a number of results to skip, to continue where an earlier run stopped. Works on LinkedIn, Glassdoor, Naukri, BDJobs and Bayt.

## `proxy` (type: `object`):

Residential proxies are selected by default and give the most reliable LinkedIn and Indeed results. You can pick another proxy group or use your own proxy URLs.

## Actor input object example

```json
{
  "searchTerm": "software engineer",
  "sites": [
    "linkedin",
    "indeed",
    "glassdoor"
  ],
  "country": "us",
  "location": "New York, NY",
  "maxResults": 20,
  "jobType": "",
  "distance": 50,
  "isRemote": false,
  "easyApply": false,
  "bdjobsCountry": "bd",
  "fetchExtraJobInfo": true,
  "descriptionFormat": "markdown",
  "enforceAnnualSalary": false,
  "deduplicate": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One row per job listing with site, title, url, applyUrl, company (name, website, industry, size), location, postedDate, jobType, salary (min, max, currency, interval), skills, benefits and descriptionText.

# 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 = {
    "searchTerm": "software engineer",
    "country": "us",
    "location": "New York, NY",
    "maxResults": 20,
    "fetchExtraJobInfo": true,
    "deduplicate": true,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("vero-api/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 = {
    "searchTerm": "software engineer",
    "country": "us",
    "location": "New York, NY",
    "maxResults": 20,
    "fetchExtraJobInfo": True,
    "deduplicate": True,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("vero-api/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 '{
  "searchTerm": "software engineer",
  "country": "us",
  "location": "New York, NY",
  "maxResults": 20,
  "fetchExtraJobInfo": true,
  "deduplicate": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call vero-api/jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vero-api/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/kAe9RwxBxI1KikVtM/builds/DnilczgbGmdoJgrsz/openapi.json