How to Query Himalayas Remote Jobs as an API Without a Paid Plan

#apify #webscraping #api #jobs

The problem

Remote-job discovery is oddly hard to do programmatically on a budget. Job boards want you on their website, and the "API" options are either enterprise-priced feeds or undocumented endpoints that break without warning. If you are a recruiter building a shortlist, a developer feeding a jobs database, or an automation builder who needs structured role facts — title, company, salary, location eligibility, application link — scraping individual job pages is fragile, slow, and rude to the source.

Himalayas.app is one of the friendlier sources: it publishes an official, public, no-auth JSON API and explicitly permits its use in applications, tools, databases, and job-board operators, with visible attribution. The only thing standing between that endpoint and your workflow is the plumbing: bounded requests, validated responses, clean rows, and honest limits.

What the actor does

The Himalayas Remote Jobs API actor turns one bounded Himalayas search into up to 20 clean, attributed job rows in an Apify Dataset. It is not a scraper — it sends exactly one request to the official /jobs/api/search endpoint per run and never touches a job page, never walks additional pages, and never submits an application.

From the README:

Predictable one-request runs. You select exactly one 1-based result page (page, 1–100); the actor does not paginate further. A successful run writes zero to 20 rows.
Full filter set: query (default software engineer), optional country, worldwide / excludeWorldwide (mutually exclusive), seniority (up to 6 levels), employmentTypes (up to 7), companySlugs (up to 10 canonical slugs like linear), timezone (e.g. UTC-5), and sort (relevant, recent, salaryAsc, salaryDesc, nameAToZ, nameZToA, jobs). Unknown fields and contradictory filter combinations are rejected before the source is contacted.
21 factual fields per row: role title, company name and slug, employment type, disclosed salary range (minSalary, maxSalary, salaryPeriod, currency), seniority, locationRestrictions and timezoneRestrictions, categories and parentCategories, publishedAt, expiresAt, the original applicationLink, and provenance (source, attributionUrl, sourceRequestUrl, fetchedAt, guid).
Attribution by design. Himalayas permits the API for tools and databases while requiring visible attribution, so every row carries source: "Himalayas", the attributionUrl, and the original application link. Employer descriptions, excerpts, and logos are deliberately excluded.
Fail-closed security posture. The only upstream host is himalayas.app on the fixed search path, with a 15-second timeout and a 2 MiB body limit; redirects, non-JSON responses, rate limits, incomplete records, schema drift, and non-Himalayas application links all fail closed instead of returning uncertain data.

Honest limits are documented: Himalayas caches its API data and refreshes roughly every 24 hours, so frequent polling adds no freshness; a valid query can return zero rows; 20 is a maximum, not a target; and salary, seniority, and eligibility values are source facts, not independently verified.

Example: input and output

The manifest's example input runs a broad recent-software search:

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

The README's illustrative output shape (it labels the company and values as fictional) shows all 21 fields:

{
  "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 or date values mean the source did not disclose that fact — they are not zero — and the README advises inspecting locationRestrictions and timezoneRestrictions together before treating a role as eligible.

Pricing and the free limit

Pay-per-event: $0.013 per actor start plus $0.001 per delivered job row (result-found), charged only after each row is successfully stored; a source failure or invalid response cannot create a paid event. A full 20-job run therefore costs $0.033 at list prices — the same cap the README's public example Task uses. Apify's free plan includes $5 of usage credits per month, which covers about 151 full 20-job runs — roughly 3,000 delivered job rows — before anything is charged. A zero-result run pays only the $0.013 start.

Try it

Run the public example Task preset or call the actor with your own filters: Himalayas Remote Jobs API.

For AI agents and MCP

The actor takes JSON in and returns structured JSON via the Apify API, so agents can call it directly with apify-client or plain HTTP, and the README ships an Apify MCP server setup for it. Himalayas also publishes its own AI-agent integration guide, and the actor is built for exactly that pattern: one bounded request, attributed factual rows, original application links for human review, and no page scraping — an agent gets clean job metadata it can branch on without ever touching an employer page.

DEV Community