# Himalayas Remote Jobs Scraper (`parsebird/himalayas-remote-jobs-scraper`) Actor
Scrape remote job listings from Himalayas — titles, salaries, seniority, employment type, company data, and full descriptions via the public search API.
- **URL**: https://apify.com/parsebird/himalayas-remote-jobs-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.89 / 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/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".
## 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.
The best way to integrate Actors is as follows.
- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).
For usage examples, see the [API](#api) section below.
For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).
# README
### Himalayas Remote Jobs Scraper
Extract remote job listings from [Himalayas](https://himalayas.app), a job board dedicated exclusively to remote positions. The **Himalayas Remote Jobs Scraper** searches by keyword, filters by seniority, employment type, and country, and returns clean, structured job data — titles, salaries, company details, tags, and full HTML descriptions — ready for analysis, monitoring, or integration into your own job board or ATS.
|
Run multiple keywords in one job, automatically deduplicate overlapping results, and filter out non-technical roles — all without touching Himalayas' rate limits, since retries on HTTP 429 are handled for you.
|
##### Copy to your AI assistant
Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.
```
Apify Actor: parsebird/himalayas-remote-jobs-scraper. Scrapes remote job listings from Himalayas (himalayas.app). Call via ApifyClient: client.actor("parsebird/himalayas-remote-jobs-scraper").call(run_input={"keywords": ["backend engineer"], "seniority": ["Senior","Mid-level"], "employmentType": "Full Time", "worldwide": true, "maxResultsPerKeyword": 50}). Returns per job: id, source, source_url, apply_url, title, description, type, work_mode, location, experience_level, salary_min, salary_max, currency, salary_period, company_name, company_slug, company_url, company_logo_url, tags, markets, posted_at, expires_at, scraped_at, data_source, data_source_url. Full API spec: https://apify.com/parsebird/himalayas-remote-jobs-scraper/api. Get your token: https://console.apify.com/settings/integrations.
```
### What does Himalayas Remote Jobs Scraper do?
This actor queries [Himalayas' public job search API](https://himalayas.app/jobs) directly — no browser, no HTML parsing, no anti-bot workarounds. You give it one or more search keywords and it returns every matching remote job with salary, seniority, employment type, location restrictions, company info, and the full job description.
- 🔍 **Multi-keyword search** — run "backend engineer", "react developer", and "devops" in a single job; results are merged and deduplicated by job ID automatically.
- 🌍 **Worldwide or country-specific filtering** — restrict to jobs explicitly open to any country, or filter to a specific country by ISO code, name, or slug.
- 🎚️ **Seniority and employment type filters** — Entry-level through Executive; Full Time, Part Time, Contractor, Temporary, Intern, Volunteer, or Other.
- 🧹 **Non-tech role filtering** — optionally strip out clearly non-technical listings (nursing, accounting, legal, driving, etc.) that occasionally appear in Himalayas' broader feed.
- 🔗 **Webhook delivery** — optionally POST every result to your own endpoint in batches of 50, authenticated with a shared secret header.
- 📊 **Sortable results** — most recent, most relevant, salary ascending/descending, or company name A–Z/Z–A.
### What job data can you extract from Himalayas?
| Field | Description |
|-------|-------------|
| `title` | Job title as posted |
| `description` | Full job description (HTML) |
| `type` | Employment type — `full-time`, `part-time`, `contract`, `temporary`, `internship`, `volunteer`, `other` |
| `work_mode` | Always `remote` — Himalayas only lists remote jobs |
| `location` | `Worldwide`, or a comma-separated list of allowed countries |
| `experience_level` | Seniority level(s) — Entry-level, Mid-level, Senior, Manager, Director, Executive |
| `salary_min` / `salary_max` / `currency` / `salary_period` | Compensation range where disclosed |
| `company_name` / `company_slug` / `company_url` / `company_logo_url` | Hiring company details |
| `tags` / `markets` | Himalayas' own role and market taxonomy |
| `posted_at` / `expires_at` | Listing publish and expiry timestamps |
| `apply_url` / `source_url` | Link to the job on Himalayas |
### Input parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `keywords` | string\[] | No | `["software engineer"]` | Keywords to search. Each keyword runs a separate search; results are deduplicated |
| `seniority` | string\[] | No | `["Senior","Mid-level","Entry-level"]` | Filter by seniority: `Entry-level`, `Mid-level`, `Senior`, `Manager`, `Director`, `Executive`. Empty = all levels |
| `employmentType` | string | No | `Full Time` | `Full Time`, `Part Time`, `Contractor`, `Temporary`, `Intern`, `Volunteer`, `Other`, or empty for any |
| `worldwide` | boolean | No | `true` | When true, only returns jobs explicitly open to candidates worldwide |
| `country` | string | No | `""` | Filter by country (ISO alpha-2 code, name, or slug, e.g. `"US"`, `"Germany"`, `"spain"`). Only applied when `worldwide` is `false` |
| `sortBy` | string | No | `recent` | `recent`, `relevant`, `salaryAsc`, `salaryDesc`, `nameAToZ`, `nameZToA` |
| `maxResultsPerKeyword` | integer | No | `100` | Max jobs to collect per keyword (1–500). Himalayas returns up to 20 results per page |
| `filterNonTech` | boolean | No | `false` | Removes clearly non-technical roles (receptionist, accountant, driver, nurse, etc.) via keyword heuristic |
| `webhookUrl` | string | No | `""` | POSTs all results to this URL in batches of 50 on completion |
| `webhookSecret` | string | No | `""` | Sent as the `X-Scraper-Secret` header when `webhookUrl` is set |
### Output example
```json
{
"id": "senior-backend-engineer-546640181",
"source": "himalayas",
"source_url": "https://himalayas.app/companies/acme-corp/jobs/senior-backend-engineer-546640181",
"apply_url": "https://himalayas.app/companies/acme-corp/jobs/senior-backend-engineer-546640181",
"title": "Senior Backend Engineer",
"description": "We are looking for a Senior Backend Engineer to join our platform team...
",
"type": "full-time",
"work_mode": "remote",
"location": "Worldwide",
"experience_level": "Senior",
"salary_min": 120000,
"salary_max": 160000,
"currency": "USD",
"salary_period": "annual",
"company_name": "Acme Corp",
"company_slug": "acme-corp",
"company_url": "https://himalayas.app/companies/acme-corp",
"company_logo_url": "https://cdn-images.himalayas.app/acme-corp-logo",
"tags": ["Backend Engineering", "Software Engineering", "Senior Backend Engineer"],
"markets": [],
"posted_at": "2026-04-20T10:30:00.000Z",
"expires_at": "2026-07-19T10:30:00.000Z",
"scraped_at": "2026-08-09T00:33:49.000Z",
"data_source": "Himalayas",
"data_source_url": "https://himalayas.app"
}
```
Download results as **JSON, CSV, Excel, HTML, or XML** directly from the Apify Console, or fetch them via the [Apify API](https://docs.apify.com/api/v2) / [dataset endpoint](https://apify.com/parsebird/himalayas-remote-jobs-scraper/api).
### Use cases
- **Remote job aggregation** — feed a job board, newsletter, or Slack/Discord bot with fresh remote listings filtered by keyword and seniority.
- **Talent sourcing pipelines** — pair `webhookUrl` with your ATS or CRM to automatically ingest new candidates' target roles as they're posted.
- **Salary benchmarking** — collect compensation data by role, seniority, and country to inform hiring budgets.
- **Market research** — track which companies and roles are hiring remotely, and how employment type and seniority mix shifts over time.
- **Competitive intelligence** — monitor how competitors' remote hiring compares across regions and levels.
### How to scrape Himalayas remote jobs
1. **Set your keywords** — add one or more search terms (e.g. `"backend engineer"`, `"react developer"`). Each keyword runs as a separate search internally.
2. **Choose filters** — pick seniority levels, employment type, and whether you want worldwide-only jobs or a specific country.
3. **Set limits** — `maxResultsPerKeyword` caps how many jobs each keyword can return (1–500).
4. **Run the actor** — click **Start** in the Apify Console, or trigger it via the [API](https://docs.apify.com/api/v2) or on a [schedule](https://docs.apify.com/platform/schedules).
5. **Get your data** — download the dataset as JSON/CSV/Excel, pull it via the API, or have it delivered straight to your `webhookUrl`.
### How much does it cost to scrape Himalayas job listings?
This actor uses [Pay-Per-Event (PPE)](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing) pricing — you're charged per job listing extracted, not per compute unit.
| Event | Price per event | Price per 1,000 |
|-------|----------------|-----------------|
| `job-scraped` (Free plan) | $0.00099 | **$0.99** |
| `job-scraped` (Bronze / Silver / Gold plans) | $0.00089 | **$0.89** |
A run collecting 500 jobs costs roughly $0.45–$0.50 depending on your Apify plan. All Apify accounts include a [free trial](https://apify.com/pricing) with credits to try the actor before committing to a paid plan.
### FAQ
**What's the difference between `location` and `country`?**
`country` is an input filter (which country to search for). `location` is an output field showing the actual countries a specific job allows, or `"Worldwide"` if there are no restrictions.
**Why are some `salary_min` / `salary_max` fields `null`?**
Not every Himalayas listing discloses a salary range. When compensation isn't published, both fields are returned as `null`.
**How does `filterNonTech` decide what's "non-technical"?**
It matches job titles against a curated keyword list (nurse, accountant, driver, receptionist, attorney, etc.). It's a heuristic, not a classifier — review results if your keywords are broad and industry-agnostic.
**Can I search for jobs from a specific company?**
Not directly through this actor's input, but you can filter `tags` in your downstream tooling, or add the company name as a keyword.
**Does this actor support scheduling and integrations?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run it daily or weekly, connect it to [Zapier, Make, or Slack](https://apify.com/integrations), or call it through the [Apify API](https://docs.apify.com/api/v2) from your own backend.
**What are the limitations of this actor?**
⚠️
- Maximum 500 results per keyword per run
- Himalayas API rate limits apply — built-in retry on 429 responses
- Individual job detail endpoint not available in public API — full description is returned directly in search results
- Results reflect Himalayas public listings only
### Is it legal to scrape Himalayas?
Yes. This actor only accesses publicly available job listings that Himalayas and its customers have made visible for the purpose of recruitment. It does not bypass login walls, access private accounts, or collect personal data about individuals. Scraping publicly available data is generally considered legal — see [Apify's overview of web scraping legality](https://www.apify.com/is-web-scraping-legal) for more detail. Users are responsible for ensuring their use of the collected data complies with applicable laws and [Himalayas' Terms of Service](https://himalayas.app/terms).
### Python and JavaScript usage
**Python** ([apify-client](https://docs.apify.com/api/client/python/)):
```python
from apify_client import ApifyClient
client = ApifyClient("")
run_input = {
"keywords": ["backend engineer"],
"seniority": ["Senior", "Mid-level"],
"employmentType": "Full Time",
"worldwide": True,
"maxResultsPerKeyword": 50,
}
run = client.actor("parsebird/himalayas-remote-jobs-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item["title"], item["company_name"])
```
**JavaScript** ([apify-client](https://docs.apify.com/api/client/js/)):
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '' });
const input = {
keywords: ['backend engineer'],
seniority: ['Senior', 'Mid-level'],
employmentType: 'Full Time',
worldwide: true,
maxResultsPerKeyword: 50,
};
const run = await client.actor('parsebird/himalayas-remote-jobs-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```
### Related Actors
- [Hiring.cafe Jobs Scraper](https://apify.com/parsebird/hiring-cafe-scraper) — 2.8M+ aggregated postings across 46 ATS platforms
- [Workable Job Scraper](https://apify.com/parsebird/workable-job-scraper) — jobs from companies hiring on Workable
- [JobsDB Job Scraper](https://apify.com/parsebird/jobsdb-job-scraper) — jobs from JobsDB (APAC)
- [JustJoin.it Jobs Scraper](https://apify.com/parsebird/justjoin-jobs-scraper) — tech jobs from Poland's JustJoin.it
- [eFinancialCareers Jobs Scraper](https://apify.com/parsebird/efinancialcareers-jobs-scraper) — finance and banking jobs
- [Workopolis Job Scraper](https://apify.com/parsebird/workopolis-job-scraper) — Canadian job listings
Browse the full catalog on the [ParseBird Apify Store page](https://apify.com/parsebird).
# Actor input Schema
## `keywords` (type: `array`):
Keywords to search on Himalayas (e.g. "software engineer", "react developer"). Each keyword runs a separate search and results are deduplicated automatically.
## `seniority` (type: `array`):
Filter by seniority level. Leave empty to include all levels.
## `employmentType` (type: `string`):
Filter by employment type. Choose "Any" to include all types.
## `worldwide` (type: `boolean`):
Only return jobs explicitly open to candidates worldwide (no location restrictions).
## `country` (type: `string`):
Filter by country. Accepts an ISO alpha-2 code, common name, or slug (e.g. "US", "Germany", "spain"). Only applied when Worldwide only is off.
## `sortBy` (type: `string`):
Sort order for results.
## `maxResultsPerKeyword` (type: `integer`):
Maximum jobs to collect per keyword. Himalayas returns up to 20 results per page.
## `filterNonTech` (type: `boolean`):
Remove clearly non-technical roles (receptionist, accountant, driver, nurse, etc.) from results using a keyword heuristic.
## `webhookUrl` (type: `string`):
If provided, all results are POSTed to this URL in batches of 50 when the run completes.
## `webhookSecret` (type: `string`):
If provided alongside Webhook URL, sent as the X-Scraper-Secret header so your endpoint can authenticate the delivery.
## Actor input object example
```json
{
"keywords": [
"software engineer"
],
"seniority": [
"Senior",
"Mid-level",
"Entry-level"
],
"employmentType": "Full Time",
"worldwide": true,
"country": "",
"sortBy": "recent",
"maxResultsPerKeyword": 20,
"filterNonTech": false,
"webhookUrl": ""
}
```
# Actor output Schema
## `dataset` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"keywords": [
"software engineer"
],
"seniority": [
"Senior",
"Mid-level",
"Entry-level"
],
"employmentType": "Full Time",
"sortBy": "recent",
"maxResultsPerKeyword": 20
};
// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/himalayas-remote-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"keywords": ["software engineer"],
"seniority": [
"Senior",
"Mid-level",
"Entry-level",
],
"employmentType": "Full Time",
"sortBy": "recent",
"maxResultsPerKeyword": 20,
}
# Run the Actor and wait for it to finish
run = client.actor("parsebird/himalayas-remote-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"
],
"seniority": [
"Senior",
"Mid-level",
"Entry-level"
],
"employmentType": "Full Time",
"sortBy": "recent",
"maxResultsPerKeyword": 20
}' |
apify call parsebird/himalayas-remote-jobs-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/himalayas-remote-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 ` 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/EOnw8j2L4mloZajZM/builds/dv5zkXQKiOQvMNaB5/openapi.json