# Himalayas Remote Jobs API — Search & Filter Remote Jobs (`nexgensignal/himalayas-remote-jobs-api`) Actor

Remote jobs from Himalayas' public jobs API: search by keyword, filter by country, seniority, type, company, timezone and pay. Salary converted to a yearly figure, full description, apply link kept. No key, no login. Part of NexGen Signal — data tools and official-source data products

- **URL**: https://apify.com/nexgensignal/himalayas-remote-jobs-api.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 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

## 🏔️ Himalayas Remote Jobs API — Search & Filter Remote Jobs

Get **remote jobs from Himalayas** (himalayas.app, about 126,000 live listings) as clean rows: title, company, employment type, seniority, pay with a **yearly figure worked out for you** (hourly × 2,080, monthly × 12…), countries and timezones the job accepts, categories, full description and the Himalayas apply link.

Search by keyword, then narrow by country, worldwide-only, seniority, employment type, company, timezone, minimum yearly pay, salary present and age. Each keyword runs Himalayas' own search, and the recent-jobs feed is scanned for more matches, so you are not limited to one page of results.

It uses Himalayas' public jobs API, which needs no key and allows commercial use on its terms (credit Himalayas, keep its apply link, do not repost to other job boards). The unit of output is one job delivered.

### Who buys this and for what job

- **Remote job boards and newsletters** that credit and link Himalayas as the source.
- **Recruiters and sales teams** finding companies hiring remotely for a role.
- **Job seekers and career tools** tracking new remote roles by skill, country and pay.
- **Analysts** studying remote pay and hiring by category.

Buyers usually search for this as **"Himalayas jobs scraper"**, **"remote jobs API"** or **"remote job listings"**.

### 📊 Sample Output

![Table of remote jobs: title, company, type, yearly pay, where and published date.](https://api.apify.com/v2/key-value-stores/IXCaMKjxSmUTLHhmq/records/himalayas-remote-jobs-api.png)

| title | company | type | yearly_pay | where | published |
|---|---|---|---|---|---|
| Machine Learning Engineer II (ROA + LTV ML) | Affirm | Full Time | 133,000–183,000 CAD | Canada | 2026-10-18 |
| AI Software Engineer | IOMETE | Full Time | — | Worldwide | 2026-10-18 |
| Data Center Virtualization Engineer | Bright Vision Technologies | Full Time | 100,000–150,000 USD | United States | 2026-10-18 |
| Senior Data Engineer | Bright Vision Technologies | Full Time | 155,000–175,000 USD | United States | 2026-10-18 |
| Principal Python Developer | Bright Vision Technologies | Full Time | 120,000–170,000 USD | United States | 2026-10-18 |
| Delivery Engineer | AltScore | Full Time | 12,000–48,000 USD | Worldwide | 2026-10-18 |
| BIM Coordinator | Rider Levett Bucknall | Full Time | — | United Kingdom | 2026-10-18 |
| Mgr Software & Product Engineering | Thryv | Full Time | — | Dominican Republic | 2026-10-18 |

Rows from live run `Y3MtS5pFgNm9fQEIS` on Apify (keywords 'data engineer' and 'product designer', 40 jobs). Notice the yearly pay column: Himalayas publishes hourly, monthly and yearly ranges, and every row also carries a yearly figure so you can sort and filter on one scale.

### ✅ What you get

Every field of each record:

- `record_id`, `job_id` — stable id from the job link (use it to upsert) and the company/job slug.
- `title`, `company_name`, `company_slug`, `company_url`, `company_logo` — the job and the company.
- `employment_type`, `seniority` — Full Time, Contractor…; Entry-level to Executive.
- `salary_min`, `salary_max`, `salary_currency`, `salary_period` — pay as published.
- `salary_annual_min`, `salary_annual_max` — the same pay as a yearly figure.
- `worldwide`, `location_restrictions`, `timezone_restrictions` — who can apply: any country, or the listed countries and UTC offsets.
- `categories`, `parent_categories`, `excerpt` — categories and the opening sentences.
- `description_text`, `description_html` — the full description (plain text by default; HTML or both on request).
- `published_at`, `expires_at` — dates in UTC.
- `apply_url`, `job_url`, `source`, `source_url` — the Himalayas apply link and job page, and the source credit.
- `search_query`, `read_at` — which of your keywords matched, and when the job was read.

### ⚙️ Sample inputs

**Python jobs (the Store example)**

```json
{
  "keywords": ["python"],
  "scanLimit": 200,
  "maxJobs": 10
}
```

Himalayas search plus 200 recent jobs scanned.

**Senior design roles open to Canada**

```json
{
  "keywords": ["product designer", "ux designer"],
  "country": "Canada",
  "seniority": ["Senior"],
  "maxJobs": 200
}
```

**Full-time jobs open in Germany paying 50,000+ a year**

```json
{
  "country": "Germany",
  "employmentTypes": ["Full Time"],
  "minAnnualSalary": 50000,
  "scanLimit": 20000,
  "maxJobs": 500
}
```

No keyword: all matching jobs in the first 20,000 of the feed.

**One company's openings**

```json
{
  "companies": ["linear", "vercel"],
  "maxJobs": 100
}
```

Input fields:

| Field | Meaning |
|---|---|
| `keywords` | job keywords; each runs a Himalayas search and is matched against the feed. Empty = all jobs. |
| `country`, `worldwideOnly` | jobs open to a country (name or ISO code), or to anyone. |
| `seniority`, `employmentTypes`, `companies`, `timezone` | narrow by level, type, company slug, UTC offset. |
| `postedWithinDays`, `minAnnualSalary`, `salaryOnly` | age, minimum yearly pay, pay present. |
| `includeDescription`, `descriptionFormat` | full description on/off; text, html or both. |
| `sortBy` | order of the search results (recent by default). |
| `scanLimit` | how many jobs of the recent-activity feed to scan (default 5,000; the feed holds about 126,000). |
| `maxJobs` | stop after this many jobs (default 1,000). Each delivered job is billed. |

### 🧾 JSON sample record

```json
{
  "record_id": "14ad7861f7170fe61dc66fbd",
  "job_id": "micro1/stem-expert-chemistry-computational-chemistry-phd",
  "title": "STEM Expert – Chemistry & Computational Chemistry (PhD)",
  "company_name": "micro1",
  "company_slug": "micro1",
  "company_url": "https://himalayas.app/companies/micro1",
  "company_logo": "https://cdn-images.himalayas.app/91oa56akgt3qjqc1nh3uoruub40c",
  "employment_type": "Contractor",
  "seniority": [
    "Mid-level",
    "Senior"
  ],
  "salary_min": null,
  "salary_max": null,
  "salary_currency": "USD",
  "salary_period": null,
  "salary_annual_min": null,
  "salary_annual_max": null,
  "worldwide": true,
  "location_restrictions": [],
  "timezone_restrictions": [
    -11,
    -10,
    -9.5,
    -9,
    -8,
    -7,
    -6,
    -5,
    -4,
    -3.5,
    -3,
    -2,
    -1,
    0,
    1,
    2,
    3,
    3.5,
    4,
    4.5,
    5,
    5.5,
    5.75,
    6,
    6.5,
    7,
    8,
    8.75,
    9,
    9.5,
    10,
    10.5,
    11,
    12,
    12.75,
    13,
    14
  ],
  "categories": [
    "Computational-Chemistry-Specialist",
    "STEM-Expert",
    "Chemistry-Expert",
    "STEM-Specialist",
    "Chemistry-Subject-Matter-Expert",
    "Computational-Chemist"
  ],
  "parent_categories": [],
  "excerpt": "Role Title: STEM Expert – Chemistry & Computational Chemistry (PhD) Role Type: Contractor Location: Remote (Worldwide) Job Summary: In this role, you’ll apply your expertise to help train next-generation AI systems.",
  "description_text": "Role Title: STEM Expert – Chemistry & Computational Chemistry (PhD)\n\nRole Type: Contractor\n\nLocation: Remote (Worldwide)\n\nJob Summary: In this role, you’ll apply your expertise to help train next-generation AI systems. Your work will shape how models learn, reason, and perform through high-quality, real-world input.\n\nKey Responsibilities:\n\nDesign, evaluate, and critique chemistry and computational…",
  "description_html": null,
  "published_at": "2026-10-17T13:00:11Z",
  "expires_at": "2026-12-16T04:55:40Z",
  "apply_url": "https://himalayas.app/companies/micro1/jobs/stem-expert-chemistry-computational-chemistry-phd",
  "job_url": "https://himalayas.app/companies/micro1/jobs/stem-expert-chemistry-computational-chemistry-phd",
  "source": "Himalayas",
  "source_url": "https://himalayas.app/jobs",
  "search_query": "python",
  "read_at": "2026-10-18T02:49:40Z"
}
```

### 🔧 How it works

For each keyword the actor reads the first page of Himalayas' search API (up to 20 best matches, with the server-side filters). Himalayas' robots.txt does not allow later search pages, so the actor then walks the public jobs feed with its cursor (20 jobs per request, about one request a second, since the keyless allowance is shared) and applies the same filters itself, matching keywords against the title, categories and description. Jobs are de-duplicated on their link.

Every run reads each host's robots.txt first: a path it disallows is skipped, listed in the run receipt and never charged. Only public internet addresses are fetched (no private, loopback or cloud-metadata addresses, checked again on every redirect). No logins, no CAPTCHA solving, no proxies.

Delivery is pushed first and charged after. The run receipt (`RUN_RECEIPT`) shows each search, how many feed jobs were scanned, how many were dropped by each filter, and the delivered and charged counts.

### 💰 Pricing example

Per job delivered, no start fee, no monthly charge:

| Apify plan | Price per job |
|---|---|
| Free | $0.05 |
| Bronze | $0.045 |
| Silver | $0.04 |
| Gold, Platinum, Diamond | $0.0335 |

- 10 jobs: $0.50 on the Free plan, $0.34 on Gold.
- 1,000 jobs: $50.00 on the Free plan, $33.50 on Gold.
- 10,000 jobs: $500.00 on the Free plan, $335.00 on Gold.

**Coverage and size.** Proof runs on 18 Oct 2026: 40 jobs for two keywords in 7 seconds; the 10-job Store example in 3 seconds; Germany + Full Time + 50,000/year over 400 scanned jobs gave 3 jobs in 27 seconds. Scanning the whole feed (about 126,000 jobs) takes roughly 1¾ hours at the shared request rate; most runs scan a few thousand.

### ⚖️ Legal & ToS

Jobs are Himalayas' listings. Himalayas' API terms allow personal and commercial integrations on three conditions: every Apply action uses the `apply_url` it supplies, Himalayas is clearly credited with a visible link, and the jobs are not redistributed to other job boards, aggregators or job search engines. Every row carries the apply link and the source so you can meet them.

Rows hold job and company fields only; no recruiter or applicant names.

Every run reads each host's robots.txt first: a path it disallows is skipped, listed in the run receipt and never charged. Only public internet addresses are fetched (no private, loopback or cloud-metadata addresses, checked again on every redirect). No logins, no CAPTCHA solving, no proxies.

### ❓ FAQ

**Do I need a Himalayas account or key?**
No. The public API is keyless.

**Why are there more matches than the search returns?**
The search gives one page (up to 20) per keyword; the feed scan finds the rest. Raise scanLimit for more.

**Can I repost these jobs on my own job board?**
Himalayas' terms ask you not to redistribute them to other job boards or aggregators. Use them in your own product with credit and the apply link.

### 🆘 Troubleshooting

- **Few results** — Raise scanLimit, or loosen the filters; RUN_RECEIPT shows how many jobs each filter dropped.
- **SOURCE UNAVAILABLE** — Himalayas did not answer after retries. Nothing was charged.

### 🔗 Related Actors

- [Sweden Active Job Ads](https://apify.com/nexgensignal/se-active-job-ad-structured-feed) — Sweden's live job-ad feed in structured rows
- [Recently Funded Startups](https://apify.com/nexgensignal/funding-round-intelligence-api) — companies that just raised money, likely to hire
- [Company Email Lookup by Domain](https://apify.com/nexgensignal/business-email-discovery-api) — reach a hiring company from its domain

🏢 **About NexGen Signal** — data tools and official-source data products. Browse the catalog: [apify.com/nexgensignal](https://apify.com/nexgensignal)

### ⭐ Found this useful?

If this actor saved you time, a rating on its Apify Store page helps other buyers find it.

Part of NexGen Signal — data tools and official-source data products.

# Actor input Schema

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

Job keywords, e.g. 'python', 'product designer'. Each keyword runs a Himalayas search; the recent-jobs feed is also scanned for jobs whose title, categories or description contain every word of a keyword. Empty = all jobs (filtered by the options below).

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

Country name or ISO code (US, Germany, IN…). Keeps jobs with no country restriction or that list this country.

## `worldwideOnly` (type: `boolean`):

Keep only jobs open to candidates in any country.

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

Keep jobs at any of these levels. Empty = all.

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

Keep jobs of any of these types. Empty = all.

## `companies` (type: `array`):

Company slugs from himalayas.app/companies/<slug>, e.g. 'linear'. Empty = all companies.

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

UTC offset you work from, e.g. -5, UTC-5 or UTC+05:30. Keeps jobs that accept it.

## `sortBy` (type: `string`):

Order of the Himalayas search results.

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

Keep jobs published in the last N days. 0 = any age.

## `minAnnualSalary` (type: `integer`):

Keep jobs whose top of range, converted to a yearly figure, is at least this (in the job's own currency). Jobs without pay are dropped when set.

## `salaryOnly` (type: `boolean`):

Drop jobs with no salary.

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

Add the full job description. Off = smaller rows (excerpt only).

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

Plain text, the original HTML, or both.

## `scanLimit` (type: `integer`):

How many jobs of the recent-activity feed to read and filter (20 per request, about one request a second). The full feed holds about 126,000 jobs. 0 = search results only.

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

Stop after this many jobs. Each delivered job is billed.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "worldwideOnly": false,
  "seniority": [],
  "employmentTypes": [],
  "companies": [],
  "sortBy": "recent",
  "postedWithinDays": 0,
  "minAnnualSalary": 0,
  "salaryOnly": false,
  "includeDescription": true,
  "descriptionFormat": "text",
  "scanLimit": 200,
  "maxJobs": 10
}
```

# Actor output Schema

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

The delivered (and billed) records.

## `receipt` (type: `string`):

Per-link outcome, robots result, delivered and charged counts.

# 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"
    ],
    "scanLimit": 200,
    "maxJobs": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/himalayas-remote-jobs-api").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"],
    "scanLimit": 200,
    "maxJobs": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/himalayas-remote-jobs-api").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"
  ],
  "scanLimit": 200,
  "maxJobs": 10
}' |
apify call nexgensignal/himalayas-remote-jobs-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/himalayas-remote-jobs-api"
        }
    }
}
```

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/euLro2paJ08Dy98X3/builds/43v9m4Sw8oooJc8lN/openapi.json