# Himalayas Remote Jobs API (`zinin/himalayas-remote-jobs-api`) Actor

Return a bounded, attributed set of current remote jobs from the official Himalayas public JSON API.

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

## Pricing

from $0.85 / 1,000 remote job delivereds

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?

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 API

Turn one bounded Himalayas search into up to 20 clean, attributed remote-job rows in an Apify Dataset. Use the rows to shortlist roles, power a job-discovery workflow, or hand structured facts to a spreadsheet, database, or agent without scraping pages.

![A bounded search becomes attributed Dataset rows](https://api.apify.com/v2/key-value-stores/2j7AzJZPwtbWzhXRL/records/himalayas-remote-jobs-api-search-workflow.png)

### What you get

- One factual Dataset row for every job delivered by the official Himalayas Remote Jobs API.
- Role, company, employment type, disclosed salary, seniority, eligibility restrictions, categories, dates, and the original Himalayas application link.
- Explicit `source`, `attributionUrl`, `sourceRequestUrl`, and `fetchedAt` provenance on every row.
- A predictable one-request run: one selected page and no hidden pagination, browser, proxy, or returned-link fetches.

The Actor ID is `eheWb74cV3foelfC4`. A ready-to-run public example is Task `find-himalayas-remote-software-jobs` (`Z9k493eIhJqOs1OHI`).

### Who it is for

This Actor fits recruiters and job seekers creating a shortlist, developers feeding a database or alerting workflow, and automation builders who need structured discovery data instead of employer prose. It is not an application bot, a complete job-feed mirror, or a license to republish employer content.

### Quick start

Use the public Task for a useful preset, or run the Actor with this input:

```json
{
  "query": "software engineer",
  "country": "Germany",
  "seniority": ["Senior"],
  "employmentTypes": ["Full Time"],
  "sort": "recent",
  "page": 1
}
```

Leave optional filters empty to keep the search broad. A successful run writes zero to 20 rows to the default Dataset. The Actor makes exactly one request to the official endpoint and never submits an application.

### Input reference

| Field | Type | Meaning |
| --- | --- | --- |
| `query` | string, 1–120 chars | Role, skill, or phrase. Default: `software engineer`. |
| `country` | string, 1–80 chars | Optional country name, code, slug, or abbreviation accepted by Himalayas. |
| `worldwide` | boolean | Keep only worldwide roles. Do not combine with `excludeWorldwide`. |
| `excludeWorldwide` | boolean | With `country`, keep country-specific matches. Requires `country`; cannot be combined with `worldwide`. |
| `seniority` | array, up to 6 | Any of Entry-level, Mid-level, Senior, Manager, Director, Executive. |
| `employmentTypes` | array, up to 7 | Full Time, Part Time, Contractor, Temporary, Intern, Volunteer, or Other. |
| `companySlugs` | array, up to 10 | Canonical lowercase Himalayas company slugs, such as `linear`. |
| `timezone` | string, up to 16 chars | A Himalayas timezone filter such as `UTC-5` or `UTC+05:30`. |
| `sort` | enum | `relevant` (default), `recent`, `salaryAsc`, `salaryDesc`, `nameAToZ`, `nameZToA`, or `jobs`. The public Task uses `recent`. |
| `page` | integer, 1–100 | Exactly one 1-based result page. The Actor does not walk further pages. |

The Actor rejects unknown fields and contradictory filter combinations before contacting the source.

### Output Dataset

Every row follows a connected Dataset schema with these 21 fields:

`source`, `attributionUrl`, `sourceRequestUrl`, `fetchedAt`, `guid`, `title`, `companyName`, `companySlug`, `employmentType`, `minSalary`, `maxSalary`, `salaryPeriod`, `currency`, `seniority`, `locationRestrictions`, `timezoneRestrictions`, `categories`, `parentCategories`, `publishedAt`, `expiresAt`, and `applicationLink`.

Illustrative shape only—the company and values below are fictional:

```json
{
  "source": "Himalayas",
  "attributionUrl": "https://himalayas.app",
  "sourceRequestUrl": "https://himalayas.app/jobs/api/search?q=software+engineer&sort=recent&page=1",
  "fetchedAt": "2026-09-01T10:00:00.000Z",
  "guid": "illustrative-guid",
  "title": "Senior Software Engineer",
  "companyName": "Example Company",
  "companySlug": "example-company",
  "employmentType": "Full Time",
  "minSalary": 120000,
  "maxSalary": 150000,
  "salaryPeriod": "year",
  "currency": "USD",
  "seniority": ["Senior"],
  "locationRestrictions": ["Worldwide"],
  "timezoneRestrictions": [],
  "categories": ["Software Development"],
  "parentCategories": ["Engineering"],
  "publishedAt": "2026-08-25T10:00:00.000Z",
  "expiresAt": null,
  "applicationLink": "https://himalayas.app/companies/example-company/jobs/illustrative-role"
}
```

Null salary and date values mean the source did not provide that fact; they are not zero. Lists can be empty. Always inspect `locationRestrictions` and `timezoneRestrictions` together before treating a role as eligible.

![Dataset rows map one-to-one to paid delivery events](https://api.apify.com/v2/key-value-stores/2j7AzJZPwtbWzhXRL/records/himalayas-remote-jobs-api-paid-dataset.png)

### Pricing and charge safety

Pay Per Event charges one Actor Start plus one `result-found` event only after each row is successfully stored in the default Dataset. A source failure, invalid response, or failed Dataset write cannot create a paid result event. The Actor checks the run budget before delivery.

| Tier | Start | Per delivered job | Maximum 20-job run |
| --- | ---: | ---: | ---: |
| FREE | $0.013000 | $0.001000 | $0.033000 |
| BRONZE | $0.012350 | $0.000950 | $0.031350 |
| SILVER | $0.011700 | $0.000900 | $0.029700 |
| GOLD | $0.011050 | $0.000850 | $0.028050 |
| PLATINUM | $0.010660 | $0.000820 | $0.027060 |
| DIAMOND | $0.010400 | $0.000800 | $0.026400 |

The public example Task is capped at the FREE maximum of `$0.033000`. A zero-result run pays the start event but no `result-found` events.

### API and automation

Run the public Task through the Apify API. Keep the token in an authorization header, secret store, or environment variable—not in Actor input or a shared URL.

```bash
curl --request POST \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{"query":"software engineer","sort":"recent","page":1}' \
  "https://api.apify.com/v2/actor-tasks/Z9k493eIhJqOs1OHI/runs?waitForFinish=60"
```

Or call the Actor directly:

```bash
curl --request POST \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{"query":"data engineer","worldwide":true,"page":1}' \
  "https://api.apify.com/v2/acts/eheWb74cV3foelfC4/runs?waitForFinish=60"
```

Read `data.defaultDatasetId` from the run response, then fetch `https://api.apify.com/v2/datasets/<DATASET_ID>/items`. The same run-and-read pattern works with the official Apify API clients and workflow tools such as Make or n8n.

### Source rights and attribution

The Actor uses the official, public, no-auth Himalayas endpoint documented in the [Remote Jobs API guide](https://himalayas.app/docs/remote-jobs-api) and [AI agent integration guide](https://himalayas.app/docs/ai-agents). Himalayas permits the API for applications, tools, databases, and job-board operators, while requiring visible attribution.

Keep `source: "Himalayas"`, the visible `attributionUrl`, and each original `applicationLink` when displaying or forwarding results. The Actor deliberately excludes employer descriptions, excerpts, and logos. You remain responsible for your downstream use, notices, retention, and compliance; do not present the rows as independently verified or use them to impersonate an employer.

### Security and data handling

- The only upstream host is `https://himalayas.app`, using the fixed `/jobs/api/search` path.
- No browser, login, proxy, redirect, application flow, or returned application link is opened.
- Upstream requests have a 15-second timeout and a 2 MiB response-body limit.
- Redirects, non-JSON responses, rate limits, incomplete records, schema drift, and non-Himalayas application links fail closed.
- No credentials are accepted or written to output. Search filters appear in `sourceRequestUrl`, so never place secrets or personal data in them.

Apify stores run input, logs, and Dataset output according to the storage and retention settings of the account that starts the run.

### Limits and interpretation

- One run makes one official search request for one selected page and returns at most 20 rows.
- The public Task is configured for 128 MB of memory and a 60-second hard timeout.
- Himalayas says its API data is cached and refreshed approximately every 24 hours; frequent polling does not add freshness.
- The Actor does not promise a complete market feed, deduplicate across separate runs, or walk all pages.
- Ranking and filter matching come from Himalayas. A valid query may return zero rows.
- Salary, seniority, location, timezone, publication, and expiry values are source facts and are not independently verified.
- An application link is a discovery path, not a guarantee that a role remains open or that a candidate is eligible.

### Troubleshooting

**No rows:** broaden `query`, remove optional filters, check that `worldwide` and `excludeWorldwide` are not combined, and try page 1. Zero rows can also be a valid current source response.

**Input rejected:** remove unknown keys, keep arrays within their documented limits, use canonical lowercase company slugs, and set `country` before `excludeWorldwide`.

**Run fails on source response:** retry later if Himalayas is rate-limiting or unavailable. The Actor intentionally refuses redirects, oversized bodies, malformed JSON, and incomplete rows instead of returning uncertain data.

**Fewer than 20 rows:** 20 is a maximum, not a target. The selected page can contain fewer matching jobs.

### FAQ

**Does it scrape job pages?** No. It sends one request to the official Himalayas JSON API.

**Can it apply for jobs?** No. It only returns the original Himalayas link for human review.

**Does it fetch every page?** No. `page` selects exactly one page per run.

**Why are salary fields null?** The source did not disclose that field for the job.

**Can I republish employer descriptions or logos?** This Actor does not collect them. Use the factual rows for discovery, preserve Himalayas attribution and source links, and assess any broader use yourself.

**What am I charged for?** One start event plus one `result-found` event for each row successfully stored. A zero-result run has no per-row charge.

# Actor input Schema

## `query` (type: `string`):

Search a role, skill or phrase. Keep this broad enough to return useful results.

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

Optional country name, ISO alpha-2 code, slug or common abbreviation accepted by Himalayas, for example US or Germany.

## `worldwide` (type: `boolean`):

Return only roles that accept candidates worldwide. Do not combine with Exclude worldwide roles.

## `excludeWorldwide` (type: `boolean`):

With Candidate country set, exclude worldwide matches and keep country-specific roles. Cannot be combined with Worldwide-only roles.

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

Optional Himalayas seniority filters. Leave empty to include every level.

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

Optional Himalayas employment-type filters. Leave empty to include every type.

## `companySlugs` (type: `array`):

Optional canonical Himalayas company slugs, such as linear or remote. Leave empty for all companies.

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

Optional UTC offset accepted by Himalayas, for example UTC-5 or UTC+05:30.

## `sort` (type: `string`):

Choose how Himalayas orders this one result page.

## `page` (type: `integer`):

Choose one 1-based Himalayas search page. The Actor never walks additional pages.

## Actor input object example

```json
{
  "query": "software engineer",
  "worldwide": false,
  "excludeWorldwide": false,
  "seniority": [],
  "employmentTypes": [],
  "companySlugs": [],
  "sort": "recent",
  "page": 1
}
```

# Actor output Schema

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

API URL for factual job-discovery rows with the original Himalayas application link. Employer description prose and company logos are not copied.

# 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 = {
    "query": "software engineer",
    "worldwide": false,
    "excludeWorldwide": false,
    "seniority": [],
    "employmentTypes": [],
    "companySlugs": [],
    "sort": "recent",
    "page": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/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 = {
    "query": "software engineer",
    "worldwide": False,
    "excludeWorldwide": False,
    "seniority": [],
    "employmentTypes": [],
    "companySlugs": [],
    "sort": "recent",
    "page": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("zinin/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 '{
  "query": "software engineer",
  "worldwide": false,
  "excludeWorldwide": false,
  "seniority": [],
  "employmentTypes": [],
  "companySlugs": [],
  "sort": "recent",
  "page": 1
}' |
apify call zinin/himalayas-remote-jobs-api --silent --output-dataset

```

## MCP server setup

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