# Himalayas Jobs Scraper (Remote Jobs with Filters) (`webdatatools/himalayas-jobs-scraper`) Actor

Scrape Himalayas remote job listings by keyword and country, with employment type, seniority, salary and posting-date filters: title, company, pay, location limits, categories and apply link.

- **URL**: https://apify.com/webdatatools/himalayas-jobs-scraper.md
- **Developed by:** [Murat Uzun](https://apify.com/webdatatools) (community)
- **Categories:** Jobs, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 1,000 jobs

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

## Himalayas Jobs Scraper (Remote Jobs with Filters)

### What is Himalayas Jobs Scraper?

Himalayas Jobs Scraper collects remote job listings from [Himalayas](https://himalayas.app) by keyword and country, and applies employment type, seniority, salary and posting-date filters to the results. Each job becomes one row: title, company, pay range, location restrictions, categories, publish and expiry dates, excerpt and the Himalayas job link. It reads Himalayas' public job API, so no login is needed.

### What data does Himalayas Jobs Scraper extract?

| Field | Type | Meaning |
|---|---|---|
| `guid` / `url` | string | Himalayas job page (canonical link) |
| `title` | string | Job title |
| `companyName`, `companySlug`, `companyUrl`, `companyLogo` | string | Employer as Himalayas lists it |
| `employmentType` | string | e.g. `Full Time`, `Part Time`, `Contractor`, `Intern` |
| `seniority` | array | e.g. `["Senior"]`, `["Entry-level"]` |
| `categories`, `parentCategories` | array | Himalayas job categories |
| `locationRestrictions` | array | Countries the job is open to (empty = no country limit) |
| `timezoneRestrictions` | array | Allowed UTC offsets (hours) |
| `minSalary`, `maxSalary`, `currency`, `salaryPeriod` | number / string | Pay as published; often empty |
| `pubDate`, `expiryDate` | ISO string | Publish and expiry time |
| `excerpt` | string | Short summary from the listing |
| `description` | string | Full description as plain text (only with "Include full description") |
| `searchQuery`, `searchCountry` | string | The search that found the row |
| `scrapedAt` | ISO string | When the row was collected |

### How to use Himalayas Jobs Scraper

1. Open the actor in Apify and go to the Input tab.
2. Enter keywords, for example `python developer`. Leave it empty to read the public browse feed, newest first.
3. Optionally set a country restriction (for example `Germany`), filters and a maximum job count.
4. Click Start and wait for the run to finish. Download the dataset as JSON, CSV or Excel.
5. For scheduled or agent use, call the actor through the Apify API with the same input.

### Example input

```json
{
    "keywords": "python developer",
    "country": "Germany",
    "employmentType": "Full Time",
    "maxJobs": 40,
    "fetchDescriptions": true
}
```

### Example output

Real row from a run on 2026-10-23 (input above; trimmed for length):

```json
{
    "position": 1,
    "guid": "https://himalayas.app/companies/novakid-school/jobs/python-backend-developer-fullstack-capable",
    "title": "Python Backend Developer, Fullstack-capable",
    "companyName": "Novakid School",
    "employmentType": "Full Time",
    "seniority": ["Senior"],
    "locationRestrictions": [],
    "minSalary": null,
    "maxSalary": null,
    "salaryPeriod": "annual",
    "pubDate": "2026-10-20T07:43:47.000Z",
    "expiryDate": "2026-12-19T07:43:46.000Z",
    "searchQuery": "python developer",
    "searchCountry": "Germany",
    "description": "Novakid is an online English school for kids. ..."
}
```

The run returned 40 rows in about 12 seconds (run `NMeg78mD0mjtB7PmD`); the platform usage of that run was USD 0.00058.

### Input parameters

- **Keywords**: search words for title, skill or company. Empty = browse feed.
- **Country restriction**: passed to the API as a country filter (for example `Germany`).
- **Employment type**: exact label, applied after the fetch.
- **Seniority**: one label, applied after the fetch.
- **Minimum salary**: keeps jobs whose top published salary is at least this value. Jobs without salary data are dropped when this is set.
- **Posted within days**: keeps jobs published in the last N days.
- **Max jobs**: upper limit for the run (up to 5,000).
- **Include full description**: adds plain-text descriptions.
- **Proxy mode**: direct first by default; residential proxy only after blocks.

### Pricing

Pay per result: **USD 0.0008 per job** at the base tier. Volume tiers lower the price for higher Apify plans (the current floor is USD 0.00048 per job). The actor start is billed as well (USD 0.00005).

Measured platform usage: USD 0.00058 for a 40-job run with descriptions, which is about USD 0.015 per 1,000 jobs in compute. Reference: the largest competing Himalayas actor on the Store charges USD 0.001 per dataset item.

### Himalayas Jobs Scraper vs. alternatives

- **Browse feed or keyword search**: the public API serves 20 jobs per page. A single keyword query returns at most 5,000 jobs (250 pages); the browse feed pages through the whole feed by cursor.
- **Filters**: employment type, seniority and salary are not API filters, so they are applied after each page. A filtered run saves fewer rows than it scans, and you pay only for saved rows.
- **Remote-only**: every Himalayas job is a remote job. For a cross-board remote feed, use the remote jobs aggregator actor from the same publisher.

### Using Himalayas Jobs Scraper with AI agents

The actor has a pay-per-result price and a schema with field descriptions, so an MCP client can call it with a keyword and read the rows directly. Pass `maxJobs` to bound the cost; the run stops at the limit or at the end of the results, whichever comes first.

### FAQ

**Does it need a login or proxy?** No. The direct API works from Apify's datacenter IPs; the residential option is there only for blocks.

**How complete is the salary data?** Himalayas publishes salary for a minority of jobs. In the 40-job test run, 4 of 40 rows had a salary; the rest have null salary fields.

**Can I combine it with other job sites?** Yes. Rows share `title`, `companyName`, `pubDate` and `url`, so one dataset per source merges cleanly.

**Why did a run return fewer rows than Max jobs?** Post-fetch filters (employment type, seniority, salary, date) drop rows; the run then reaches the end of results or the page limit.

**Is the description complete?** It is the HTML description from the API, converted to plain text. Formatting is simplified (lists become "- " lines).

**What about errors?** If nothing matches or the API stops responding, the actor writes a record named ERRORS in the key-value store and does not charge for rows it did not save.

### Support

Open an issue on the actor's Issues tab. Himalayas is a third-party site; this actor is not affiliated with Himalayas.

# Actor input Schema

## `keywords` (type: `string`):

Search words for job title, skill or company, e.g. `python developer`. Leave empty to read the public browse feed (newest jobs first).

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

Only jobs open to people in this country, e.g. `Germany`, `United States`, `Canada`. Uses the API country filter.

## `employmentType` (type: `string`):

Applied after the fetch. Exact label as the API shows it, e.g. `Full Time`, `Part Time`, `Contractor`, `Intern`.

## `seniority` (type: `string`):

Applied after the fetch. One label, e.g. `Entry-level`, `Mid-level`, `Senior`, `Manager`, `Director`.

## `minSalary` (type: `integer`):

Keeps jobs whose maximum published salary is at least this number (same currency and period as listed). Jobs without salary data are dropped when this is set.

## `postedWithinDays` (type: `integer`):

Keep only jobs published in the last N days, e.g. `7`.

## `maxJobs` (type: `integer`):

Upper limit for the whole run (20 jobs per API page; a single query returns at most 5,000 jobs).

## `fetchDescriptions` (type: `boolean`):

Adds the HTML description converted to plain text. Off by default to keep rows short.

## `proxyMode` (type: `string`):

auto: direct first, Apify Residential proxy only after blocks. never: direct only. always: Residential from the start.

## Actor input object example

```json
{
  "keywords": "python developer",
  "maxJobs": 100,
  "fetchDescriptions": false,
  "proxyMode": "auto"
}
```

# Actor output Schema

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

All remote jobs from this run.

# 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 = {
    "keywords": "python developer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatatools/himalayas-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 = { "keywords": "python developer" }

# Run the Actor and wait for it to finish
run = client.actor("webdatatools/himalayas-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 '{
  "keywords": "python developer"
}' |
apify call webdatatools/himalayas-jobs-scraper --silent --output-dataset

```

## MCP server setup

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