…
", "descriptionText": "…", "publishedAt": "2026-10-18T11:51:38.000Z", "expiresAt": "2026-12-17T11:51:37.000Z", "applicationLink": "https://himalayas.app/companies/acme/jobs/senior-backend-engineer", "sourceUrl": "https://himalayas.app/companies/acme/jobs/senior-backend-engineer", "source": "Himalayas", "attribution": "Source: Himalayas (https://himalayas.app/companies/acme/jobs/senior-backend-engineer)", "retrievedAt": "2026-10-18T13:38:52.452Z" } ``` - `applicationLink` is exactly what the API sent. We never replace it with an employer or ATS link. - `salary` is `null` when the posting states no pay (about 60% of jobs). `yearlyMin`/`yearlyMax` are filled only when the pay period is known: hourly x 2,080, weekly x 52, fortnightly x 26, monthly x 12, annual x 1. - An empty `locationRestrictions` means the job is open worldwide; an empty `timezoneRestrictions` means any timezone. - Every run also saves a `RUN_SUMMARY` record: requests, pages, jobs delivered, expired jobs dropped, Himalayas' own API notice, and any error. You can export as JSON, CSV, Excel or XML, or read it through the Apify API. **Fill rates** in our 2026-10-18 sample (215 jobs): title, company, employment type, seniority, categories, timezone, excerpt, description, dates and links 100%; location restrictions 92% (the rest are worldwide); parent categories 83%; company logo 89%; salary 36%. ### Pricing Pay per event: - **$0.0007 per job** saved to the dataset. - Apify's standard tiny start fee per run. 1,000 jobs cost **$0.70**. A daily alert with *Only new jobs* typically returns a few dozen jobs, a couple of cents a day. Cap any run with Apify's *Max total charge*. The Actor stops at the cap, and jobs already delivered are remembered by *Only new jobs*, so you never pay twice for the same job. Expired jobs are dropped before they are delivered, so you are never charged for them. ### Use it via API, n8n or Make For your own alerts, research and internal tools (not for feeding job boards, aggregators or job search engines; see *Terms of use*). Get an API token in Apify Console → *Settings* → *API & Integrations*, and keep it in an environment variable (`APIFY_TOKEN` below). **cURL** (starts a run, waits for it and returns the jobs as JSON; this synchronous endpoint waits up to 5 minutes, which fits up to about 2,000 jobs; for more use the clients below): ```bash curl -X POST "https://api.apify.com/v2/acts/ataism~himalayas-jobs/run-sync-get-dataset-items?token=$APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"query": "data engineer", "worldwideOnly": true, "sort": "recent", "maxItems": 50}' ``` **JavaScript** (`npm install apify-client`): ```js import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: process.env.APIFY_TOKEN }); const run = await client.actor('ataism/himalayas-jobs').call({ query: 'data engineer', sort: 'recent', maxItems: 100, onlyNew: true, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); for (const job of items) console.log(job.companyName, job.title, job.salary?.yearlyMin, job.applicationLink); ``` **Python** (`pip install "apify-client>=3"`): ```python import os from apify_client import ApifyClient client = ApifyClient(os.environ["APIFY_TOKEN"]) run = client.actor("ataism/himalayas-jobs").call(run_input={ "query": "data engineer", "sort": "recent", "maxItems": 100, "onlyNew": True, }) for job in client.dataset(run.default_dataset_id).iterate_items(): print(job["companyName"], job["title"], job["applicationLink"]) ``` (With apify-client versions before 3.0, `call()` returns a dict: use `run["defaultDatasetId"]`.) **n8n** (new jobs to your own Slack channel): 1. Add a *Schedule Trigger* (daily; Himalayas refreshes its data about every 24 hours). 2. Add the **Apify** node, operation **Run an Actor and get dataset**, Actor `ataism/himalayas-jobs`, and paste your input JSON with `"onlyNew": true`. 3. Add a *Slack* (or email) node and post `title`, `companyName`, `applicationLink` and the `attribution` credit with its Himalayas link (terms 113(a) and (b)). **Make:** 1. Add the **Apify** module **Run an Actor**, choose `ataism/himalayas-jobs`, paste the input JSON and set *Run synchronously* to *Yes*. 2. Add the **Apify** module **Get Dataset Items** and map the run's default dataset ID. 3. Send the rows to your own Slack, email or internal sheet, keeping `applicationLink` and the Himalayas credit. Schedule the scenario daily. ### Terms of use This Actor uses the Himalayas Remote Jobs API and follows [Himalayas' Terms and Conditions for API Users](https://himalayas.app/terms) (section 113), which apply to you as well: > 113. These terms apply when you use the Himalayas Remote Jobs API, including with an API key. You may use the API in personal and commercial integrations on these conditions: > (a) Every Apply action for a job from Himalayas must use the applicationLink supplied by the API. Do not replace it with a direct employer or applicant tracking system link. > (b) Clearly identify Himalayas as the source of the jobs, with a visible link to the Himalayas job or to himalayas.app. > (c) Do not redistribute jobs from Himalayas to other job boards, aggregators or job search engines. > (d) Cache job data where you can, stay within your request limits, and remove jobs once they expire. > (e) Keep your API keys private and use them only from your own servers. > (f) API keys grant read access to public job data only. We set and may change request limits, and we may suspend keys or accounts that break these terms. For higher limits or other uses, contact hi@himalayas.app. How the Actor and you each follow it: - **(a) Apply links.** Every row carries `applicationLink` unchanged. If you build anything with an Apply button, use that link. - **(b) Source credit.** Every row has `source: "Himalayas"`, a `sourceUrl` (the Himalayas job page) and an `attribution` string. If you show these jobs to anyone, show the credit and the link. - **(c) No redistribution.** **Do not publish these jobs on another job board, aggregator or job search engine** (Google Jobs and LinkedIn Jobs included). Use the data for research, analysis, alerts and internal tools only. You are responsible for how you use the output. - **(d) Caching and expiry.** Expired jobs are dropped by default (`includeExpired` is off). *Only new jobs* avoids re-delivering what you've seen and stops reading once it reaches jobs you already have. Requests are sequential with a pause between them. Himalayas' [API docs](https://himalayas.app/docs/remote-jobs-api) say the data is cached and refreshed every 24 hours, so running more often than daily is unlikely to help. If you store jobs yourself, delete them once `expiresAt` has passed. - **(e) Keys.** Himalayas says API keys are for use "only from your own servers", so this Actor has no key input and runs keyless on Himalayas' public allowance. Don't ask us to add a key. We're not affiliated with Himalayas. ### Limits and errors No key is used: keyless callers share one public allowance with everyone else, and Himalayas doesn't publish the exact figure. The Actor makes one request per 20 jobs, sequentially, 1.2 s apart. If Himalayas answers 429 (too many requests), it waits (the `Retry-After` time if given, otherwise an increasing pause) and retries; if it still fails it ends the run with a clear message, keeping what was already delivered. A run reads at most 300 requests (6,000 jobs scanned); if it hits that cap it logs a warning and says so in `RUN_SUMMARY` (`stoppedBy: "maxPages"`). ### Privacy Job listings only. To avoid passing on personal data, the Actor **removes email addresses and phone numbers** from titles, excerpts and descriptions (you'll see `[email removed]` or `[phone removed]`). In our 2026-10-18 sample this changed 4 of 215 descriptions. Free-text tricks such as "jane (at) example (dot) com" may not be caught. ### Reliability - Reads the official JSON API with cursor paging (the deprecated `offset` isn't used), so website redesigns don't break it. - A daily self-test checks the live API against a recorded baseline: field names and fill rates. If Himalayas changes its own release notes, we're told and look at it, but nothing breaks. We fix breakages fast. - **Only new jobs** saves its memory at least every 5 jobs. If a run is killed hard (for example an out-of-memory crash), up to 4 jobs delivered just before that may be delivered, and charged, again on the next run. Normal aborts and migrations save everything. ### FAQ **How many jobs are there?** About 128,000 in the full feed on 2026-10-18, including many that are old but not yet expired. The newest-updated come first; use filters to narrow down. **Why did my run stop before Max jobs?** Either the results ran out, the *Max total charge* was reached, or the 300-request cap was hit (see *Limits and errors*). `RUN_SUMMARY.stoppedBy` says which. **Does Max jobs count expired jobs?** No. Only delivered (non-expired, and with *Only new*, unseen) jobs count. **Can I put the jobs on my job board?** No. That is exactly what Himalayas' terms forbid. **Something's wrong?** Open an issue on the Actor's Issues tab. We aim to reply within 2 working days. # Actor input Schema ## `query` (type: `string`): Free-text search, e.g. "react engineer". Leave empty to read the full newest-first feed. ## `countries` (type: `array`): Keep jobs open to applicants in these countries (ISO code or name, e.g. "US", "Germany"). One search is made per country, so more countries means more requests. ## `worldwideOnly` (type: `boolean`): Only jobs with no country restriction. ## `seniority` (type: `array`): Experience levels to keep. Leave empty for all. ## `employmentTypes` (type: `array`): Leave empty for all. ## `companies` (type: `array`): Himalayas company slugs, e.g. "linear" (the last part of himalayas.app/companies/linear). ## `timezones` (type: `array`): UTC offsets, e.g. "1", "-5", "5.5", "UTC+1" or "UTC+05:30" (checked against the live API). One search is made per timezone. ## `sort` (type: `string`): Only for filtered searches. With no filter and no sort, the full feed is read newest-updated first. Choosing a sort switches to the search endpoint. ## `maxItems` (type: `integer`): Stop after this many jobs. Searches return at most 5,000 results. ## `includeExpired` (type: `boolean`): Off by default: Himalayas' terms require removing jobs once they expire. ## `includeDescription` (type: `boolean`): Adds the description as HTML and as plain text. Turn off for a smaller dataset. ## `onlyNew` (type: `boolean`): Skip jobs this Actor already returned to you (remembered for 120 days in a key-value store named "himalayas-jobs-state" in your account). Ideal for scheduled alerts: you only pay for new jobs, and the Actor stops reading once it reaches jobs you've already seen. ## `stateKey` (type: `string`): Use different names to keep separate only-new memories for different saved tasks. ## `mode` (type: `string`): Internal: "selfTest" runs the maintainer health check and saves no jobs. ## Actor input object example ```json { "worldwideOnly": false, "maxItems": 20, "includeExpired": false, "includeDescription": true, "onlyNew": false, "stateKey": "default", "mode": "scrape" } ``` # Actor output Schema ## `results` (type: `string`): Himalayas remote job listings, one item per row (JSON, CSV, Excel or XML). ## `runSummary` (type: `string`): Counts, expired jobs dropped, API notice and errors for this run. # 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 '