Remote Jobs API

The Himalayas Jobs API is a free, public JSON endpoint that returns remote job listings. No API key or authentication is required. Send a GET request to the endpoint, and you receive structured job data including titles, salaries, company info, and application links.

What is the Himalayas Jobs API?

The Himalayas Jobs API is a REST endpoint that returns remote job listings in JSON format. It is designed for developers, researchers, and content creators who want to integrate remote job data into their own applications, dashboards, or websites.

The API is free to use and requires no authentication. It returns the same job data that powers the Himalayas job board, including job titles, company details, salary ranges, location and timezone restrictions, categories, and direct 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.

What is the API endpoint URL?

The API endpoint is:

https://himalayas.app/jobs/api

Send a GET request to this URL to receive a JSON response containing remote job listings. No headers, tokens, or API keys are required.

What query parameters does the API accept?

The API accepts two optional query parameters:

• offset: The number of jobs to skip before returning results. Use this for pagination. Defaults to 0.
• limit: The maximum number of jobs to return per request. Defaults to 20. Maximum value is 20.

Example request for the second page of results:

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

What does the API response look like?

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

• updatedAt: ISO 8601 timestamp of when the data was last refreshed
• offset: The offset used in this request
• 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
• companyLogo: URL of the company logo image
• employmentType: Full-time, part-time, contract, etc.
• minSalary: Minimum annual salary (number, or null if not provided)
• maxSalary: Maximum annual salary (number, or null if not provided)
• 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: Publication date as an ISO 8601 string
• expiryDate: Expiration date as an ISO 8601 string
• applicationLink: Direct URL to the company's application page
• guid: Unique identifier for the job listing

How do I paginate through all jobs?

Use the offset and limit parameters to page through results. Start with offset=0, then increment by the limit value for each subsequent request.

For example, to retrieve all jobs 20 at a time:

1. First request: ?offset=0&limit=20
2. Second request: ?offset=20&limit=20
3. Third request: ?offset=40&limit=20
4. Continue until offset exceeds the totalCount value from the response

The totalCount field tells you how many jobs are available in total, so you know when to stop paginating.

What is the rate limit?

The API is rate limited. If you exceed the rate limit, you will receive a 429 Too Many Requests response. 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 API, RSS feed, and MCP server?

Himalayas offers three ways to access job data programmatically:

• JSON API: Returns all jobs with pagination. Best for building applications, databases, or dashboards. Up to 20 jobs per request, paginate to get all. Updated every 24 hours.
• RSS Feed: Returns the 100 most recent jobs in XML/Atom format. Best for feed readers and content aggregators. No pagination. Updated every 24 hours.
• MCP Server: Provides real-time search via AI assistants like Claude, Cursor, and Windsurf. Best for conversational job search and AI integrations. Returns live results.

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?

import requests

response = requests.get(
    "https://himalayas.app/jobs/api",
    params={"limit": 20, "offset": 0}
)
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:

import requests

offset = 0
limit = 20
all_jobs = []

while True:
    response = requests.get(
        "https://himalayas.app/jobs/api",
        params={"limit": limit, "offset": offset}
    )
    data = response.json()
    all_jobs.extend(data["jobs"])
    offset += limit
    if offset >= data["totalCount"]:
        break

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

How do I fetch jobs with Node.js?

const response = await fetch(
  "https://himalayas.app/jobs/api?limit=20&offset=0"
);
const data = await response.json();

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

What does the full response schema look like?

{
  "comments": "string — API release notes",
  "updatedAt": "number — Unix timestamp (ms)",
  "offset": "number — offset used",
  "limit": "number — limit used",
  "totalCount": "number — total jobs available",
  "jobs": [
    {
      "title": "string",
      "excerpt": "string",
      "companyName": "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 ms)",
      "expiryDate": "number (Unix timestamp ms)",
      "applicationLink": "string (URL)",
      "guid": "string"
    }
  ]
}

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

What error responses does the API return?

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.