# Himalayas Jobs Scraper: Remote Jobs API (`subimpact/himalayas-jobs-scraper`) Actor

Remote jobs from Himalayas' public API as JSON: title, company, apply link, categories, seniority, employment type, location and timezone limits, salary range, dates and full plain-text description. Filter by keyword, country, timezone and seniority. $0.80 per 1,000 jobs.

- **URL**: https://apify.com/subimpact/himalayas-jobs-scraper.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** Jobs, Developer tools, AI
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 job scrapeds

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 API

Scrape **remote job listings from Himalayas** as clean JSON, using Himalayas' free public Remote Jobs API. One row per job: title, company, logo, application link, categories, seniority, employment type, location and timezone restrictions, salary range, posting and expiry dates, excerpt and the full description as plain text.

No browser, no scraping proxy, no login. The API returns JSON directly, so a run is fast and cheap — and you can filter server-side by keyword, country, timezone, seniority and employment type.

### What you get

- **One dataset row per unique job**, de-duplicated on the Himalayas job id even across several keyword searches.
- **Full job descriptions** with HTML stripped to readable plain text (paragraph and list breaks kept).
- **Structured salary**: `minSalary`, `maxSalary`, `currency`, `salaryPeriod` (null when the employer does not disclose pay).
- **Eligibility data**: `locationRestrictions` (empty = worldwide) and `timezoneRestrictions` as `UTC-5`-style strings.
- **Apply and source links**: `url` is Himalayas' `applicationLink`, unchanged; `himalayasUrl` is the canonical job page for attribution.
- **ISO-8601 dates**: `pubDate` (Himalayas' last-updated time) and `expiryDate`.
- **Free error rows**: a failed request is delivered with `status: "Error"` and an `error` message, and is never charged.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array of strings | *(empty)* | Keywords, for example `["react", "product designer"]`. Each query is its own request series; results are de-duplicated. Empty walks the newest-jobs feed. |
| `categories` | array of strings | *(empty)* | Local filter on job categories and parent categories, for example `["React", "Software-Engineer"]`. Case-insensitive substring match. |
| `seniority` | array of enum | *(empty)* | `Entry-level`, `Mid-level`, `Senior`, `Manager`, `Director`, `Executive`. Applied by the API. |
| `employmentTypes` | array of enum | *(empty)* | `Full Time`, `Part Time`, `Contractor`, `Temporary`, `Intern`, `Volunteer`, `Other`. Applied by the API. |
| `countries` | array of strings | *(empty)* | Only jobs open to candidates in these countries, for example `["US", "Germany"]`. One country per API request, so each adds a request series. |
| `timezones` | array of strings | *(empty)* | Only jobs whose timezone restrictions include these offsets, for example `["-5", "UTC+05:30"]`. Each adds a request series. |
| `postedWithinDays` | integer | `0` | Keep jobs whose `pubDate` is within this many days. `0` disables the filter. |
| `maxJobs` | integer | `100` | Delivered-row cap for the whole run (1 to 5000). The default run costs about **$0.08**. |
| `requestDelayMs` | integer | `1000` | Pause between API requests. The Actor is deliberately polite to the keyless API. |

#### Example input

```json
{
  "searchQueries": ["react", "product designer"],
  "countries": ["US"],
  "seniority": ["Senior"],
  "employmentTypes": ["Full Time"],
  "categories": ["React"],
  "postedWithinDays": 30,
  "maxJobs": 200
}
```

With no input at all, the Actor walks the newest remote jobs feed and delivers up to 100 jobs.

### Output

Every field is present on every row. Job rows have `status: "Success"` and `error: null`; free diagnostic rows have `status: "Error"`, a message in `error`, and null job fields.

```json
{
  "jobId": "https://himalayas.app/companies/clera/jobs/founding-product-designer-engineer-4714369289",
  "title": "Founding Product Designer/Engineer",
  "companyName": "Clera",
  "companySlug": "clera",
  "companyLogo": null,
  "url": "https://himalayas.app/companies/clera/jobs/founding-product-designer-engineer-4714369289?utm_source=api",
  "himalayasUrl": "https://himalayas.app/companies/clera/jobs/founding-product-designer-engineer-4714369289",
  "categories": ["Founding-Product-Designer", "Founding-Product-Engineer", "Product-Design-Engineer"],
  "seniority": ["Executive", "Senior"],
  "employmentType": "Full Time",
  "locationRestrictions": ["United States"],
  "timezoneRestrictions": ["UTC-10", "UTC-9", "UTC-8", "UTC-7", "UTC-6", "UTC-5", "UTC+14"],
  "minSalary": 160000,
  "maxSalary": 220000,
  "currency": "USD",
  "salaryPeriod": "annual",
  "pubDate": "2026-11-15T01:37:32.000Z",
  "expiryDate": "2027-01-14T01:37:31.000Z",
  "excerpt": "About the RoleAs the first dedicated product design hire at an AI company, you will shape how the product looks, feels, and works.",
  "description": "About the Role\nAs the first dedicated product design hire at an AI company, you will shape how the product looks, feels, and works. You will partner with company leadership and engineering to build intuitive interfaces that help operators work with AI agents.\nWhat You'll Do\n\n- Take product ideas from sketches through user flows and frontend implementation.\n\n- Design and build interfaces…",
  "scrapedAt": "2026-11-15T08:20:39.000Z",
  "status": "Success",
  "error": null
}
```

*(A real row from a live run; the description is shortened here for readability. The Actor delivers the full text.)*

### Pricing

**$0.80 per 1,000 jobs** — $0.0008 per delivered job, no start fee, platform usage included. You are charged only after a job row is delivered. Error rows, filtered-out jobs and duplicates are free. A default run (100 jobs) costs about **$0.08**.

### Spend controls

- `maxJobs` caps delivered rows (default 100, maximum 5000).
- The Actor respects the platform's `ACTOR_MAX_PAID_DATASET_ITEMS` and maximum-charge limit: it stops as soon as the limit is reached and stops fetching further pages.
- Rows are pushed and charged one at a time, so a run that hits a limit or times out still delivers everything it collected.
- A full run summary (scanned, delivered, duplicates, filtered, free error rows, requests) is saved to the key-value store under `OUTPUT`.

### Data source and attribution

Job data comes from **Himalayas** ([himalayas.app](https://himalayas.app)), via its free public [Remote Jobs API](https://himalayas.app/api). The API requires no key or sign-up; this Actor sends no credentials. Please follow [Himalayas' API terms](https://himalayas.app/terms#api):

- Use the **`applicationLink`** (our `url` field) for every Apply button, unchanged.
- Show a **visible link to the job on Himalayas** (our `himalayasUrl` field) or to himalayas.app as the source.
- Show the jobs only on sites and apps you operate. Do not pass them on to other job boards, aggregators, Google Jobs or LinkedIn Jobs, including through feeds or JobPosting structured data.
- **Remove jobs once they expire** — check `expiryDate`, or re-check the job with the API, because jobs can close before that date.

Himalayas refreshes its job data daily. This Actor is not affiliated with Himalayas.

### How it works and limits

- Keywords and the country, timezone, seniority and employment-type filters are sent to the Himalayas **search** endpoint, 20 jobs per page. With no filters at all, the Actor walks the full feed with the documented **cursor** pagination.
- `categories` and `postedWithinDays` are applied locally after fetching, because the API has no parameter for them. That means a filtered run may scan more rows than it delivers.
- `pubDate` is Himalayas' **last-updated** time, not necessarily the original posting date; use `postedWithinDays` with that in mind.
- Himalayas' `totalCount` is an estimate and can be up to a day old. Results can also shift between pages, so rows are always de-duplicated on the job id.
- The live API returns timezone restrictions as numbers; this Actor normalises them to strings such as `UTC-5`. Location restrictions may be strings or objects upstream and are normalised to country names.
- A missing `companyLogo`, salary or currency is delivered as `null` rather than dropped.
- One page is 20 jobs. The Actor requests pages one at a time with a one-second pause between requests by default; the keyless rate limit is lower than the 60 requests/minute documented for free API keys.
- Every pushed field is declared in the dataset schema, so the dataset can be exported or sent through the Apify API without schema errors.

### Run monitoring and privacy

If a run fails or times out, this Actor tells its developer the run ID and status, so we can fix problems fast. It never sends your input, your results or your account data.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search, for example react, python or product designer. Each query is its own request series and results are de-duplicated across queries. Leave empty to walk the newest-jobs feed instead.

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

Keep only jobs whose categories or parent categories contain one of these values, for example Software-Engineer, React, Product-Management. Matching is case-insensitive substring matching. The Himalayas API has no category parameter, so these jobs are still fetched and then filtered locally.

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

Keep jobs at these seniority levels. Leave empty for all levels.

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

Keep jobs with these employment types. Leave empty for all types.

## `countries` (type: `array`):

Only jobs open to candidates in these countries. Use ISO alpha-2 codes or names, for example US, GB, Germany. The API accepts one country per request, so each country adds its own request series; results are de-duplicated.

## `timezones` (type: `array`):

Only jobs whose timezone restrictions include one of these UTC offsets, for example -5, UTC-5 or UTC+05:30. Each timezone adds its own request series; results are de-duplicated.

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

Keep jobs whose Himalayas pubDate is within this many days. 0 disables the filter. Himalayas documents pubDate as the job's last-updated time.

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

Cap on delivered job rows for the whole run (1 to 5000, default 100). The default run costs about $0.08. Rows are charged only after they are delivered.

## `requestDelayMs` (type: `integer`):

Pause between Himalayas API requests in milliseconds (0 to 10000, default 1000). The API refreshes daily and its keyless rate limit is lower than the documented 60 requests/minute for free API keys, so the Actor is deliberately gentle. Lower it only if you have your own allowance.

## Actor input object example

```json
{
  "searchQueries": [
    "react"
  ],
  "postedWithinDays": 0,
  "maxJobs": 100,
  "requestDelayMs": 1000
}
```

# Actor output Schema

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

One dataset item per unique job: jobId, title, company, logo, application URL, Himalayas source URL, categories, seniority, employment type, location and timezone restrictions, salary range and period, published and expiry dates, excerpt and plain-text description. Error rows carry status Error and are free.

## `runSummary` (type: `string`):

Counters for the run: jobs delivered, jobs scanned, duplicates skipped, rows filtered out, free error rows, pages and bytes downloaded.

# 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 = {
    "searchQueries": [
        "react"
    ],
    "maxJobs": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/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 = {
    "searchQueries": ["react"],
    "maxJobs": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("subimpact/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 '{
  "searchQueries": [
    "react"
  ],
  "maxJobs": 100
}' |
apify call subimpact/himalayas-jobs-scraper --silent --output-dataset

```

## MCP server setup

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