# Himalayas Jobs: Remote Jobs, Salary, Time Zones (`deepmine/himalayas-jobs-scraper`) Actor

Search Himalayas remote jobs by keyword: title, company, salary range, seniority, time zones, locations, category, posted and expiry dates and the full description in every row. Filter by country, date, job type, seniority, time zone and salary. For job boards, newsletters and job seekers.

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

## Pricing

from $0.39 / 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: Remote Jobs, Salary, Time Zones

Himalayas jobs scraper: type a keyword like software engineer or marketing and get Himalayas remote jobs with title, company, seniority, salary, time zones, locations, apply link and the full description, newest first.

| 💼 Title | 🏢 Company | 🎚️ Seniority | 💰 Salary | 🕐 Time Zones | 📍 Location |
|---|---|---|---|---|---|
| Team Lead, Android Core Product | Speechify | Manager | USD 140,000 - 200,000 per year | UTC-10, UTC-9, UTC-8 | United States |
| Staff Applied AI Engineer | Premier Global Links | Senior | USD 250,000 - 300,000 per year | UTC-10, UTC-9, UTC-8 | United States |
| Senior/Lead Back End Engineer | Remofirst | Senior | – | UTC+2 | Romania |

<sub>Collected 2026-10-08.</sub>

**$0.49 per 1,000 jobs** on the Starter plan ($0.58 Free, $0.44 Scale, $0.39 Business). The prefilled run (up to 100 jobs: 50 software engineer and 50 marketing jobs of the last 7 days) costs about $0.05.

It reads Himalayas' public job search at run time: no login, no browser, no cookies. The prefilled run on 2026-10-08 delivered 95 jobs (50 software engineer, 45 marketing) in 9 seconds, the first one 3.4 seconds after the start. 44 of the 95 listed a salary, and every job had its seniority, time zones, category, expiry date and full description.

Want more boards in one list? [Remote Jobs Aggregator](https://apify.com/deepmine/remote-jobs-aggregator) searches Himalayas, Remote OK, We Work Remotely, Jobicy, Relomote, Arbeitnow and Working Nomads at once.

### What you can do with it

- **Feed a job board, newsletter or Slack channel** with fresh Himalayas jobs: schedule a daily run with `postedWithinDays` set to 2, or add an Apify webhook to send each finished run to your own system.
- **Find jobs you can actually take**: filter by the country you live in, your time zone (`timezone`), seniority and a minimum US-dollar salary.
- **Benchmark remote pay**: the **💰 With Salary** list holds every job with a published salary, with numbers you can sort and average.
- **Track who's hiring remotely** for a skill or role, by company, seniority and category.

### Input

```json
{
  "keywords": ["software engineer", "marketing"],
  "postedWithinDays": 7,
  "maxJobsPerKeyword": 50,
  "seniority": ["Senior"],
  "timezone": "UTC+1"
}
```

| Field | What it does |
|---|---|
| `keywords` | What to search for, one per line: a skill, role or tool (software engineer, product designer, python). A job matches when every word is in its title, company or Himalayas' own role labels; a skill or tool also matches in the description. Title matches go first. An empty list gives the latest Himalayas jobs of every kind. |
| `categories` | Optional. Keep only jobs in these categories (the boards' own categories, in common words). Leave empty for every category. |
| `country` | Optional. A country you live in (United States, Germany, India, Brazil...): keeps the jobs open to its residents, including jobs open worldwide and jobs for its region (Europe, LATAM, APAC, North America). Type Worldwide for only the jobs open to anyone, anywhere. Leave empty for every job. |
| `postedWithinDays` | Keep only jobs posted in the last N days; older ones cost nothing. 0 means any date. Handy for a daily or weekly scheduled run. |
| `maxJobsPerKeyword` | The jobs to keep per keyword: the best matches (title matches first), newest first. You pay per job, so this caps the cost per keyword. 0 means every job. Default 100. |
| `boards` | Fixed to `himalayas` (hidden in the form). |
| `employmentTypes` | More filters. Optional. Keep only these job types. A job whose board doesn't give its type (and whose title doesn't say, e.g. 'Contract') is left out. Leave empty for every type. |
| `seniority` | More filters. Optional. Keep only these levels (Himalayas gives a level on every job). Leave empty for every level. |
| `minSalary` | More filters. Optional. Keep only jobs that list a salary in US dollars whose top of range is at least this, per year (hourly and monthly pay are converted). Jobs with no listed salary, or pay in another currency, are left out. 0 means no salary filter. |
| `timezone` | More filters. Optional UTC offset you work in, e.g. UTC-5, UTC+1, UTC+5:30. Keeps the jobs that accept it (Himalayas lists the time zones of each job). |
| `maxResults` | Advanced. Stop after this many jobs in total. You pay per job, so this caps the run's cost. |
| `includeDescription` | Advanced. The full job description as plain text. Same price either way; turn it off for smaller rows. |
| `includeDescriptionHtml` | Advanced. Also the board's description as HTML (links and lists kept), in descriptionHtml. Same price; rows get about twice as big. |
| `findContactEmails` | Advanced. For jobs whose description gives no email, look for one on the company's own website (its home, contact and careers pages). Charged per job that gets an email this way; emails a description gives are always included free. Works when the company's website is known (We Work Remotely lists it) or can be confirmed from its name. Slower: test runs of about 45 jobs took 1.5 to 2.5 minutes with it, 22 seconds without. |
| `proxyConfiguration` | Advanced. Apify Proxy (datacenter) by default; the boards' feeds are public, so it only spreads the requests over several IPs. Residential and SERP proxies are replaced with datacenter. Turn it off to connect directly. |

### Output

One row per job, newest first, as soon as Himalayas answers. A job that several keywords find comes once, under the first keyword that found it.

Two datasets, both with the same rows:

- **💼 All Jobs** (default dataset). Views: **🏔️ Himalayas Jobs** (🖼️ Logo, 💼 Title, 🏢 Company, 🎚️ Seniority, 💰 Salary, 🕐 Time Zones, 📍 Location, 🕒 Job Type, 🗂️ Category, 📅 Posted, 🏢 Company Page, 🔗 Job Page), then **📊 Overview**, **📝 Details** and **📇 Contacts**.
- **💰 With Salary**: the delivered jobs that publish a salary, at no extra charge.

#### Output fields

In row order:

- `companyLogo`: the company's logo from the board.
- `title`: job title.
- `company`: company name.
- `location`: where a hire may live, in short: `Anywhere`, `United States`, `Europe, United Kingdom`.
- `isWorldwide`: `true` when anyone anywhere can apply, `false` when the board names places.
- `employmentType`: `Full-time`, `Part-time`, `Contract`, `Temporary`, `Internship` or `Volunteer`.
- `seniority`: `Entry-level`, `Mid-level`, `Senior`, `Manager`, `Director` or `Executive`.
- `category`: the board's category in common words (Software Development, Design, Marketing...).
- `salary`: published pay, e.g. `USD 140,000 - 200,000 per year`. Empty when the job lists none.
- `salaryMin`: the lowest pay in the range, as a number.
- `salaryMax`: the highest pay in the range, as a number.
- `salaryCurrency`: ISO currency code, e.g. `USD`.
- `salaryPeriod`: `year`, `month`, `2 weeks`, `week`, `day` or `hour`.
- `postedAt`: when the job was published, in UTC (`2026-10-08T14:36:55Z`).
- `expiresAt`: when the board takes the listing down, in UTC.
- `jobUrl`: the job's page on the board.
- `applyUrl`: where to apply: the employer's own link when the description gives one, else the board's page.
- `contactEmail`: a contact email the description gives (or, with `findContactEmails`, the company's website).
- `contactEmailSource`: the page the email was found on.
- `companyWebsite`: the company's own website: Himalayas doesn't list it, so it's filled only with `findContactEmails`.
- `companyUrl`: the company's page on the board.
- `locations`: every country or region the board lists.
- `timezones`: UTC offsets a hire must work in (`UTC-5`), or `Any`.
- `tags`: skills and labels the board gives the job.
- `boardCategory`: the board's own category name as it prints it.
- `description`: the full job description as plain text (on by default).
- `descriptionHtml`: the description as HTML. Only with `includeDescriptionHtml`.
- `sources`: the board that lists the job.
- `sourceUrls`: the job's page on that board.
- `jobId`: the job's id on the board.
- `keywords`: your keywords that found the job. Empty for a run without keywords.
- `scrapedAt`: when this run read the job (UTC).

Example row (description shortened):

```json
{
  "companyLogo": "https://cdn-images.himalayas.app/vsrucc45861zk54llb081a7mxva8",
  "title": "Team Lead, Android Core Product - Burlington, VT, USA",
  "company": "Speechify",
  "location": "United States",
  "isWorldwide": false,
  "employmentType": "Full-time",
  "seniority": "Manager",
  "category": "Software Development",
  "salary": "USD 140,000 - 200,000 per year",
  "salaryMin": 140000,
  "salaryMax": 200000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "postedAt": "2026-10-08T14:33:03Z",
  "expiresAt": "2026-12-07T14:33:02Z",
  "jobUrl": "https://himalayas.app/companies/speechify/jobs/team-lead-android-core-product-burlington-vt-usa",
  "applyUrl": "https://himalayas.app/companies/speechify/jobs/team-lead-android-core-product-burlington-vt-usa",
  "contactEmail": null,
  "contactEmailSource": null,
  "companyWebsite": null,
  "companyUrl": "https://himalayas.app/companies/speechify",
  "locations": [
    "United States"
  ],
  "timezones": [
    "UTC-10",
    "UTC-9",
    "UTC-8",
    "UTC-7",
    "UTC-6",
    "UTC-5",
    "UTC+14"
  ],
  "tags": [
    "Android Team Lead",
    "Android Engineer",
    "Android Lead",
    "Mobile Engineering Team Lead",
    "Senior Android Engineer",
    "Android Engineering Lead",
    "Mobile Software Engineer Lead"
  ],
  "boardCategory": "Developer",
  "description": "Remote\n\nThe mission of Speechify is to make sure that reading is never a barrier to learning.\n\nOver 50 million people use Speechify's text-t ...",
  "descriptionHtml": null,
  "sources": [
    "Himalayas"
  ],
  "sourceUrls": [
    "https://himalayas.app/companies/speechify/jobs/team-lead-android-core-product-burlington-vt-usa"
  ],
  "jobId": "speechify/team-lead-android-core-product-burlington-vt-usa",
  "keywords": [
    "software engineer"
  ],
  "scrapedAt": "2026-10-08T15:07:58Z"
}
```

The run's **🧾 Run summary** (the OUTPUT record in the key-value store) shows how many jobs Himalayas sent and matched per keyword, plus any error.

### Credit the boards

Himalayas shares its jobs on the condition that you credit it: keep each job's `sourceUrls` (a link back to the original posting) and name the board from `sources` when you show the jobs to others. Himalayas asks that its jobs aren't submitted to third-party job sites such as Google Jobs, LinkedIn Jobs or Jooble.

### When something goes wrong

- If Himalayas doesn't answer after several retries on fresh IPs, or answers in a format we can't read, the run ends as **failed** with the reason in the status message and the run summary, so you notice.
- If Himalayas asks us to slow down (HTTP 429), the run waits as long as it asks and tries again.
- A keyword with no Himalayas job gives a clean empty result and a status message saying so.
- When `maxResults` or your spending limit is reached, the run stops after delivering every job the limit pays for; you pay only for the jobs delivered.

### Pricing

You pay per job delivered: $0.49 per 1,000 jobs on the Starter plan ($0.58 Free, $0.44 Scale, $0.39 Business). Descriptions, salaries and apply links are included at the same price. No start fee. With `findContactEmails` on, a job that gets its contact email from the company's website adds $0.98 per 1,000 such jobs. Requests, retries, jobs left out by your filters and the 💰 With Salary list cost nothing.

Examples: the prefilled run (up to 100 jobs) about $0.05; 1,000 jobs $0.49; 5,000 jobs $2.45.

### FAQ

**How many jobs does a keyword reach?** Himalayas' search goes up to 5,000 jobs per keyword. `maxJobsPerKeyword` keeps the best matches (title matches first), and `maxResults` caps the whole run.

**How fresh is the data?** Each run reads Himalayas at run time, so a job comes in as soon as it's posted. Himalayas posts hundreds of remote jobs a day.

**Can I get new jobs every day?** Yes: save your input as a task, schedule it daily and set `postedWithinDays` to 2. A job two runs find comes in both; dedupe on `jobUrl`.

**Does it collect personal data?** Rows hold jobs and companies, no recruiter profiles.

### Feedback

Missing a field or a filter? Open an issue on the Issues tab and we'll look at it. If the data helped you, a short review on this page helps other people find it.

# Actor input Schema

## `keywords` (type: `array`):

What to search Himalayas for, one keyword per line: a skill, role or tool (python, product designer, customer support). Leave the list empty for the latest jobs of every kind. You pay per job delivered.

## `categories` (type: `array`):

Optional. Keep only jobs in these categories (the boards' own categories, in common words). Leave empty for every category.

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

Optional. A country you live in (United States, Germany, India, Brazil...): keeps the jobs open to its residents, including jobs open worldwide and jobs for its region (Europe, LATAM, APAC, North America). Type Worldwide for only the jobs open to anyone, anywhere. Leave empty for every job.

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

Keep only jobs posted in the last N days; older ones cost nothing. 0 means any date. Handy for a daily or weekly scheduled run.

## `maxJobsPerKeyword` (type: `integer`):

The jobs to keep per keyword: the best matches (title matches first), newest first. You pay per job, so this caps the cost per keyword. 0 means every job. Default 100.

## `boards` (type: `array`):

Fixed to Himalayas in this Actor. To search seven remote job boards at once, use Remote Jobs Aggregator.

## `employmentTypes` (type: `array`):

Optional. Keep only these job types. A job whose board doesn't give its type (and whose title doesn't say, e.g. 'Contract') is left out. Leave empty for every type.

## `seniority` (type: `array`):

Optional. Keep only these levels (Himalayas gives a level on every job). Leave empty for every level.

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

Optional. Keep only jobs that list a salary in US dollars whose top of range is at least this, per year (hourly and monthly pay are converted). Jobs with no listed salary, or pay in another currency, are left out. 0 means no salary filter.

## `timezone` (type: `string`):

Optional UTC offset you work in, e.g. UTC-5, UTC+1, UTC+5:30. Keeps the jobs that accept it (Himalayas lists the time zones of each job).

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

Stop after this many jobs in total. You pay per job, so this caps the run's cost.

## `includeDescription` (type: `boolean`):

The full job description as plain text. Same price either way; turn it off for smaller rows.

## `includeDescriptionHtml` (type: `boolean`):

Also the board's description as HTML (links and lists kept), in descriptionHtml. Same price; rows get about twice as big.

## `findContactEmails` (type: `boolean`):

For jobs whose description gives no email, look for one on the company's own website (its home, contact and careers pages). Charged per job that gets an email this way; emails a description gives are always included free. Works when the company's website is known (We Work Remotely lists it) or can be confirmed from its name. Slower: test runs of about 45 jobs took 1.5 to 2.5 minutes with it, 22 seconds without.

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

Apify Proxy (datacenter) by default; the boards' feeds are public, so it only spreads the requests over several IPs. Residential and SERP proxies are replaced with datacenter. Turn it off to connect directly.

## Actor input object example

```json
{
  "keywords": [
    "software engineer",
    "marketing"
  ],
  "postedWithinDays": 7,
  "maxJobsPerKeyword": 50,
  "boards": [
    "himalayas"
  ],
  "minSalary": 0,
  "maxResults": 1000,
  "includeDescription": true,
  "includeDescriptionHtml": false,
  "findContactEmails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `withSalaryUrl` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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": [
        "software engineer",
        "marketing"
    ],
    "postedWithinDays": 7,
    "maxJobsPerKeyword": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/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": [
        "software engineer",
        "marketing",
    ],
    "postedWithinDays": 7,
    "maxJobsPerKeyword": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/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": [
    "software engineer",
    "marketing"
  ],
  "postedWithinDays": 7,
  "maxJobsPerKeyword": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call deepmine/himalayas-jobs-scraper --silent --output-dataset

```

## MCP server setup

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