Skip to main content
JSON API

AI and developers

Remote Jobs API Reference

Full technical reference for the Himalayas Remote Jobs API — all endpoints, query parameters, response schema, pagination, rate limits, and code examples in Python and Node.js.

Published

The Himalayas Remote Jobs API is a free public JSON API for remote job data. No API key is required; a free API key gives you higher rate limits and usage tracking. Use the browse endpoint when you want the full jobs feed with pagination, and use the search endpoint when you want filtered results by keyword, country, company slug, seniority, employment type, timezone, sort order, or page.

What is the Himalayas Remote Jobs API?

The Himalayas Remote Jobs API is designed for developers, researchers, job board operators, content creators, and AI tools that need machine-readable remote job data from Himalayas.

The API is free to use. Create and manage keys on the API keys page. It returns the same job data that powers the Himalayas job board, including job titles, company details, salary ranges, location restrictions, timezone restrictions, categories, and application links.

If you are looking for an XML feed instead, see the Remote Jobs RSS Feed. For AI assistant integration, see the Remote Jobs MCP Server. To show jobs on your site without writing code, use the Remote Jobs Widget.

Do I need an API key?

No. Every endpoint works without a key or sign-up, so you can start right away. We recommend a free API key for anything beyond a quick test, because keyed requests get higher rate limits and a daily usage count.

Get a free API key or manage existing keys. Sign up with email or Google, verify your email, then create a key and accept the API terms. A public company or candidate profile is not required.

Keys grant only jobs:read for the endpoints below. They cannot manage candidate or employer accounts and do not replace MCP OAuth access. Copy a new key once and store it on your server; never put it in browser code, a URL, source control or a log.

Terminal
curl --header "Authorization: Bearer $HIMALAYAS_API_KEY" \
  "https://himalayas.app/jobs/api?limit=20"

Requests without a key keep working. Keys are checked whenever a request reaches our servers: invalid, revoked, suspended or unverified credentials return 401, and temporarily unavailable authorization returns 503. Responses served from our cache are public job data, so they are returned without a key check. Errors are never cached.

Keyed requests get higher limits: 60 requests per minute and 10,000 per UTC day for the account, shared across all its keys. Requests without a key share one public allowance with every other caller. Responses served from our cache are free and do not count; only requests that reach our servers do, even if the data request then fails. A keyed 429 includes Retry-After in seconds plus X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset for the daily window and matching X-RateLimit-Minute-* headers for the minute window. Successful responses do not carry these headers, because they can be cached and shared; check your usage on the API keys page. Reset values are Unix seconds. Separate IP abuse controls can also return 429.

The API keys page shows your daily allowance and requests per key today. Contact hi@himalayas.app for a higher allowance. To replace a key, create a new one, update and test your integration, then revoke the previous key. Revocation and suspension are checked on every request that reaches our servers.

Every Apply action must use the API's applicationLink, not a direct employer/ATS link. Display visible Himalayas source credit. You can show the jobs on your own job board, site or app without asking us first. Do not pass them on to other job boards, aggregators, Google Jobs or LinkedIn Jobs, including through feeds or JobPosting structured data. These obligations apply to commercial and personal integrations; see the API terms.

What endpoints does the API provide?

The API currently provides three endpoints:

https://himalayas.app/jobs/api
https://himalayas.app/jobs/api/search
https://himalayas.app/jobs/api/companies/:company/jobs/:slug

Use /jobs/api for the full unfiltered jobs feed, /jobs/api/search for filtered search results, and the third to check one job is still open.

How do I check a job is still open?

Take the job's guid and put /jobs/api after the domain:

https://himalayas.app/companies/linear/jobs/senior-product-engineer        (guid)
https://himalayas.app/jobs/api/companies/linear/jobs/senior-product-engineer
  • 200: the job is open. The body is { "job": { ... } } in the same shape as the feed.
  • 410: the job has closed. Remove it. The body includes expiryDate, when it closed.
  • 404: there is no job at this path in the API.

Jobs can close before their expiryDate, for example when the employer takes the posting down. Re-read the feed daily and drop jobs that are no longer in it, or check a job with this endpoint before showing it. Answers are cached for up to 10 minutes. Please use this endpoint rather than requesting job pages, which are protected against automated traffic. Without an API key it allows 60 requests a minute.

Browse all jobs with pagination

Use the browse endpoint when you want the full remote jobs feed:

https://himalayas.app/jobs/api

The browse endpoint accepts these optional query parameters:

  • cursor: An opaque pointer to your position in the feed. Take the nextCursor value from a response and pass it back to get the following page. This is the preferred way to paginate.
  • limit: The maximum number of jobs to return per request. Defaults to 20. Maximum value is 20.
  • offset: The number of jobs to skip before returning results. Deprecated. Still supported, but it will be removed in a future release. Use cursor instead. Defaults to 0.

Example request for the second page of results:

https://himalayas.app/jobs/api?limit=20&cursor=MjAyNi0wOC0yMVQwODozODoxNC4xNzc1NTBafDIwNjc2OTc

Do not build or parse cursor values yourself. The format is opaque and may change; treat a cursor as a token you echo back.

If you want to query by keyword, country, worldwide availability, seniority, employment type, company slug, timezone, sort order, or page, use the search endpoint section below.

Search jobs with filters

Use the search endpoint when you want filtered job results:

https://himalayas.app/jobs/api/search

The search endpoint currently accepts these query parameters:

  • q: Free-text query
  • country: Country filter
  • worldwide: Worldwide-only filter
  • exclude_worldwide: Exclude worldwide matches when country is present
  • seniority: One or more seniority values
  • employment_type: One or more employment type values
  • company: One or more company slugs
  • timezone: Timezone filter
  • sort: Sort order
  • page: 1-based results page

Search API examples:

https://himalayas.app/jobs/api/search?q=react%20engineer
https://himalayas.app/jobs/api/search?country=US&seniority=Senior&sort=recent
https://himalayas.app/jobs/api/search?company=linear&employment_type=Full%20Time
https://himalayas.app/jobs/api/search?q=python&sort=salaryDesc&page=2

What does the API response look like?

The API returns a JSON object with the following top-level fields:

  • updatedAt: Unix timestamp in seconds of the most recently updated job in the response
  • nextCursor: Pass this back as ?cursor= to fetch the next page. Omitted once there are no further pages. Its absence is how you know the walk is finished.
  • offset: The offset used in this request. Always 0 on a cursor request, since offset played no part in selecting the page (deprecated, prefer cursor)
  • limit: The limit used in this request
  • totalCount: The total number of remote jobs available
  • jobs: An array of job objects

What fields does each job include?

Each job object in the jobs array includes the following fields:

  • title: Job title (e.g., "Senior Software Engineer")
  • excerpt: Short plain-text summary of the job
  • companyName: Name of the hiring company
  • companySlug: Canonical company slug for filtering and stable lookups (e.g., "stripe")
  • companyLogo: URL of the company logo image
  • employmentType: Full-time, part-time, contract, etc.
  • minSalary: Minimum salary in the stated pay period (number, or null if not provided)
  • maxSalary: Maximum salary in the stated pay period (number, or null if not provided)
  • salaryPeriod: Pay period for salary fields — hourly, weekly, fortnightly, monthly, or annual (default)
  • seniority: Experience level (e.g., "Senior", "Mid", "Junior")
  • currency: Salary currency code (e.g., "USD", "EUR")
  • locationRestrictions: Array of countries where applicants must be based (empty array means worldwide)
  • timezoneRestrictions: Array of accepted timezone offsets (empty array means all timezones)
  • categories: Array of job categories (e.g., "Engineering", "Design")
  • parentCategories: Array of parent category groupings
  • description: Full job description as sanitized HTML
  • pubDate: When the job was last updated, as a Unix timestamp in seconds
  • expiryDate: The latest the job stays listed, as a Unix timestamp in seconds. Jobs can close earlier
  • applicationLink: URL to the job's application page on Himalayas
  • guid: Unique identifier for the job listing

How do I paginate through all jobs?

Use cursor. Make a first request without one, then pass the nextCursor from each response back as ?cursor= on the next request. When a response has no nextCursor, you have reached the end of the feed.

  1. First request: ?limit=20
  2. Response contains "nextCursor": "MjAyNi0wOC0yMVQ..."
  3. Second request: ?limit=20&cursor=MjAyNi0wOC0yMVQ...
  4. Repeat until a response has no nextCursor field

Cursor pagination is both faster and more reliable than offset. It stays fast no matter how deep into the feed you are, whereas offset requests get slower the further you go.

It is also more accurate. The feed is ordered by most recently updated, so positions shift while you are paging. With offset, that means a job can be returned twice or missed entirely. A cursor pins your exact position, so a cursor walk will never return the same job twice.

One thing a cursor cannot protect you from: a job that is updated while you are walking moves to the front of the feed, ahead of your position, so it will not appear in your remaining pages. If you are building a complete mirror of the feed, re-run the walk from the start periodically to pick those up.

Paginating with offset (deprecated)

offset still works, and existing integrations will keep functioning, but it will be removed in a future release. If you are still using it, start with offset=0 and increment by limit on each request, continuing until offset exceeds totalCount. We recommend migrating to cursor when convenient.

What is the rate limit?

Requests with a free API key get higher limits: 60 per minute and 10,000 per UTC day for your account, shared across its keys. Requests without a key share one public allowance with every other caller. Responses served from our cache are free and do not count against your limit. If you exceed a limit, you will receive a 429 Too Many Requests response; with a key, it includes Retry-After in seconds and X-RateLimit-* headers. See API keys above.

The data is cached and refreshed every 24 hours, so there is no benefit to polling more frequently than once per day.

If you need a higher rate limit for a specific use case, contact the team at hi@himalayas.app.

How often is the data updated?

The API data is cached and refreshed every 24 hours. New job postings, expirations, and updates are reflected in the API within this window. For real-time results, use the Himalayas MCP Server which queries live data.

What is the difference between the Remote Jobs API, RSS feed, and MCP server?

Himalayas offers several ways to access job data programmatically:

  • Browse API (/jobs/api): The full jobs feed with cursor pagination. Up to 20 jobs per request. Best for building apps, databases, or dashboards. Updated every 24 hours.
  • Search API (/jobs/api/search): Filtered job results by keyword, country, seniority, employment type, company, timezone, and more. Returns the same job shape as the browse API. Best when you need targeted results without crawling the full feed.
  • RSS Feed: The 100 most recent jobs in XML/Atom format. Best for feed readers and content aggregators. No pagination. Updated every 24 hours.
  • MCP Server: Real-time job search, salary benchmarks, company research, and application tracking via AI assistants like Claude, Cursor, and Windsurf. Best for conversational job search and AI agent integrations.

For the RSS feed, see Remote Jobs RSS Feed. For MCP, see Remote Jobs MCP Server.

What are the attribution requirements?

If you display Himalayas job data on your own website or application, include a visible link back to himalayas.app and mention that the data is sourced from Himalayas. This helps support the platform and ensures users can find the original listings.

Is there an OpenAPI specification?

Yes. The Himalayas Jobs API is described by an OpenAPI 3.1 specification:

https://himalayas.app/docs/openapi.json

The spec includes the full request and response schema, all query parameters with types and constraints, enum values for fields like employmentType and currency, and error response definitions. Use it to auto-generate client libraries or validate responses.

How do I fetch jobs with Python?

Python
import os
import requests

response = requests.get(
    "https://himalayas.app/jobs/api",
    params={"limit": 20}
)
data = response.json()

print(f"Total jobs: {data['totalCount']}")
for job in data["jobs"]:
    salary = ""
    if job["minSalary"] and job["maxSalary"]:
        salary = f" ({job['currency']} {job['minSalary']:,}–{job['maxSalary']:,})"
    print(f"{job['title']} at {job['companyName']}{salary}")

To paginate through all jobs:

Python
import os
import time
import requests

cursor = None
all_jobs = []

while True:
    params = {"limit": 20}
    if cursor:
        params["cursor"] = cursor

    response = requests.get("https://himalayas.app/jobs/api", params=params, headers={"Authorization": f"Bearer {os.environ['HIMALAYAS_API_KEY']}"})
    if response.status_code == 429:
        time.sleep(int(response.headers.get("Retry-After", "60")))
        continue  # Retry this same cursor after the shared allowance resets.
    response.raise_for_status()
    data = response.json()
    all_jobs.extend(data["jobs"])

    cursor = data.get("nextCursor")
    if not cursor:
        break

print(f"Fetched {len(all_jobs)} jobs")

How do I fetch jobs with Node.js?

JavaScript
const response = await fetch("https://himalayas.app/jobs/api?limit=20", { headers: { Authorization: `Bearer ${process.env.HIMALAYAS_API_KEY}` } });
const data = await response.json();

console.log(`Total jobs: ${data.totalCount}`);
data.jobs.forEach((job) => {
  console.log(`${job.title} at ${job.companyName}`);
});

To paginate through all jobs:

JavaScript
let cursor = null;
const allJobs = [];

while (true) {
  const url = new URL("https://himalayas.app/jobs/api");
  url.searchParams.set("limit", "20");
  if (cursor) url.searchParams.set("cursor", cursor);

  const response = await fetch(url, { headers: { Authorization: `Bearer ${process.env.HIMALAYAS_API_KEY}` } });
  if (response.status === 429) {
    const seconds = Number(response.headers.get('Retry-After') || 60);
    await new Promise(resolve => setTimeout(resolve, seconds * 1000));
    continue; // Retry the same cursor, including the first page.
  }
  if (!response.ok) throw new Error(`Jobs API returned ${response.status}`);
  const data = await response.json();
  allJobs.push(...data.jobs);
  cursor = data.nextCursor;
  if (!cursor) break;
}

console.log(`Fetched ${allJobs.length} jobs`);

What does the full response schema look like?

JSON
{
  "comments": "string - API release notes",
  "updatedAt": "number - Unix timestamp (seconds)",
  "nextCursor": "string - pass back as ?cursor= for the next page. Omitted on the last page",
  "offset": "number - offset used (deprecated, prefer cursor)",
  "limit": "number - limit used",
  "totalCount": "number - total jobs available",
  "jobs": [
    {
      "title": "string",
      "excerpt": "string",
      "companyName": "string",
      "companySlug": "string",
      "companyLogo": "string (URL)",
      "employmentType": "string (enum: Full Time | Part Time | Contractor | Temporary | Intern | Volunteer | Other)",
      "minSalary": "number | null",
      "maxSalary": "number | null",
      "seniority": ["string (enum: Entry-level | Mid-level | Senior | Manager | Director | Executive)"],
      "currency": "string (ISO 4217)",
      "locationRestrictions": [{ "alpha2": "string", "name": "string", "slug": "string" }],
      "timezoneRestrictions": ["string (UTC offset)"],
      "categories": ["string"],
      "parentCategories": ["string"],
      "description": "string (sanitized HTML)",
      "pubDate": "number (Unix timestamp, seconds)",
      "expiryDate": "number (Unix timestamp, seconds)",
      "applicationLink": "string (URL)",
      "guid": "string"
    }
  ]
}

For valid enum values and detailed field descriptions, see the Data Dictionary.

What error responses does the API return?

StatusMeaningWhen
200SuccessValid request with results
400Bad RequestInvalid query parameters, such as a non-numeric offset or a cursor that was not returned as a nextCursor
401UnauthorizedThe API key is invalid, revoked or suspended, or the Authorization header is not Bearer YOUR_API_KEY
404Not FoundThe single-job endpoint has no job at that path
410GoneThe single-job endpoint's job has closed
429Too Many RequestsRate limit exceeded. Wait and retry; with a key, Retry-After gives the seconds
503Service UnavailableSearch or API key checks are temporarily unavailable. Retry shortly

When rate limited, wait and retry. The data refreshes every 24 hours, so there is no benefit to polling more frequently.

Where can I get help?

For API questions, higher rate limits, or integration support, email the team at hi@himalayas.app.

For AI agent integration guides, see the AI Agents hub. For field definitions and valid values, see the Data Dictionary. For general documentation, see How Remote Jobs Work on Himalayas.

⌂ 换网址