# Himalayas Remote Jobs Scraper – Real-Time Data (`b2b_leads/himalayas-real-time-data-scraper`) Actor

Collect live Himalayas remote jobs in real time: keyword search with country, seniority, and contract filters, full-feed browse, company tracking, and URL lookup. Structured JSON streamed to your dataset as each record is finalized.

- **URL**: https://apify.com/b2b_leads/himalayas-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Himalayas Real-Time Data

Live remote-job intelligence from Himalayas — one of the largest remote job boards. Search 100k+ verified remote positions by keyword, country, seniority, and contract type, walk the full feed, track hiring at specific companies, or refresh saved job URLs. Every record streams to your dataset as structured JSON the moment it is finalized.

> **Free trial:** runs on the Apify free plan return a 2-result sample per run. Upgrade to a paid Apify plan for full, unlimited data.

### Who this is for

- **Recruiters & sourcing teams** building remote talent pipelines and tracking who is hiring
- **Job seekers & career coaches** monitoring new remote openings by role, country, and seniority
- **Startup researchers & investors** watching hiring velocity at specific companies
- **Salary analysts** benchmarking remote pay ranges by role and region
- **AI agents & automation builders** feeding fresh remote-job data into CRMs, alerts, and dashboards

### Use cases

1. Monitor new remote openings for a role (e.g. “product designer”) and push them to Slack daily
2. Build a target-employer watchlist and track every new opening at those companies
3. Benchmark remote salary ranges across roles, seniority levels, and countries
4. Backfill a job board or internal database from the full live feed
5. Refresh a saved shortlist of job URLs with current details
6. Power an AI job-matching agent with structured, always-fresh postings

### Features

| Feature | What it does | Default |
|---|---|---|
| 💼 Job search | Keyword search with country, worldwide-only, seniority, employment-type, and sort filters | **On** (`software engineer`, 10 jobs) |
| ✨ Fetch full details | Adds full description text + posting/expiry dates to the same row (`detailsFetched: true`) | Off |
| 📡 Browse full feed | Walks the entire live feed, newest first, up to your cap | Off |
| 🏢 Company jobs | Live openings at specific companies by slug (e.g. `stripe`, `lemon-io`) | Off |
| 🔗 Scrape by URL | Full records from explicit Himalayas job URLs | Off |
| 📣 Delivery | JSON or Slack webhook push per record, plus streaming dataset writes | Optional |

Every discovered job is exported. Filtering never drops rows: with enrichment off you get fast cards; with it on, the same rows carry full details.

### Input reference

- `enableJobSearch` (boolean, default `true`) — run keyword searches.
- `jobKeywords` (string list, default `["software engineer"]`) — one search runs per keyword.
- `jobCountry` (string, default `""`) — e.g. `"United States"`, `"Germany"`. Empty = worldwide.
- `worldwideOnly` (boolean, default `false`) — only jobs open worldwide.
- `seniority` (string list, default `[]`) — any of `Entry-level`, `Mid-level`, `Senior`, `Manager`, `Director`, `Executive`.
- `employmentType` (string list, default `[]`) — any of `Full Time`, `Part Time`, `Contractor`, `Temporary`, `Intern`, `Volunteer`, `Other`.
- `jobSort` (string, default `"relevant"`) — `relevant` | `recent` | `salaryAsc` | `salaryDesc` | `nameAToZ` | `nameZToA` | `jobs`.
- `jobsPerQuery` (integer, default `10`, max `1000`) — cap per keyword search.
- `fetchFullDetails` (boolean, default `false`) — enrich rows in place.
- `enableBrowseFeed` (boolean, default `false`) + `feedMaxJobs` (integer, default `10`, max `5000`).
- `enableCompanyJobs` (boolean, default `false`) + `companySlugs` (string list, e.g. `["stripe"]`) + `jobsPerCompany` (integer, default `10`).
- `enableScrapeByUrl` (boolean, default `false`) + `jobUrls` (string list of `himalayas.app/companies/.../jobs/...` URLs).
- `webhookUrl` (string) + `webhookFormat` (`json` | `slack`).
- `proxyConfiguration` (proxy) — Residential US proxies recommended.

Empty input still runs a useful demo: job search for `software engineer`, 10 jobs.

### Output fields

Each dataset row is one job: `featureType`, `jobId`, `title`, `company`, `companySlug`, `companyLogo`, `location`, `locationRestrictions`, `timezoneRestrictions`, `salary`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `snippet`, `categories`, `seniority`, `postedAt`, `expiryDate`, `employmentType`, `descriptionText` (with enrichment / URL rows), `detailsFetched`, `jobUrl`, `applicationLink`, `searchQuery`, `searchCountry`, `position`, `source`, `scrapedAt`.

The run `OUTPUT` includes `totalPushed`, `enabledFeatures`, `errors`, and a `paywall` object (`detected`, `isPaying`, `pricingTier`, `limited`, `blocked`, `freeTierMaxItems`).

### Webhooks

Set `webhookUrl` to receive each record in real time **in addition to** the dataset write. `json` delivers the raw record; `slack` delivers a formatted message with title, company, location, salary, and link. Delivery is fire-and-forget: failures are logged and never stop the run.

### MCP / AI-agent usage

Pair with the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp-server): connect your agent, start this Actor with a role keyword, then ask questions over the dataset.

Example prompt: *“Using the latest Himalayas Real-Time Data run for ‘customer success’, which remote-first companies posted this week and what pay ranges did they list?”*

### FAQ

- **Which proxy should I use?** Residential proxies (US default) give the freshest results. Local runs use the DataImpulse residential gateway via `.env`.
- **What does the free tier include?** A 2-result sample per run so you can verify the schema. Upgrade for unlimited rows.
- **How fresh is the data?** Every run collects live listings at run time — what you get is what is posted right now.
- **Do detail rows cost more?** The `result` pay-per-event charge applies per exported row; enrichment adds a little extra time per record but no extra rows.

# Actor input Schema

## `enableJobSearch` (type: `boolean`):

Search live Himalayas remote jobs by keyword with optional country, seniority, and employment-type filters. Returns fast cards: title, company, locations, salary when shown, and snippet. On by default.

## `jobKeywords` (type: `array`):

Keywords for the Himalayas search, e.g. "software engineer", "product designer", "customer success". One search runs per keyword.

## `jobCountry` (type: `string`):

Limit results to jobs open in one country, e.g. "United States", "Germany", "India". Leave empty to search worldwide.

## `worldwideOnly` (type: `boolean`):

Only return jobs open to applicants worldwide. Off by default.

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

Filter by seniority level. Valid values: Entry-level, Mid-level, Senior, Manager, Director, Executive. Empty means all levels.

## `employmentType` (type: `array`):

Filter by contract type. Valid values: Full Time, Part Time, Contractor, Temporary, Intern, Volunteer, Other. Empty means all types.

## `jobSort` (type: `string`):

Sort order for search results: best match, newest first, salary, or company name.

## `jobsPerQuery` (type: `integer`):

Cap the number of jobs collected per keyword search. This is the main cost lever for job search.

## `fetchFullDetails` (type: `boolean`):

Enrich each job row in place with its full description text, posting and expiry dates. Every job is still exported even when details are unavailable (nothing is dropped). Adds a little extra time per record.

## `enableBrowseFeed` (type: `boolean`):

Walk the full live Himalayas remote-jobs feed, newest first, with no keyword filter. Useful for backfills and market-wide scans. Off by default — turn on and set the cap.

## `feedMaxJobs` (type: `integer`):

Cap the number of jobs collected from the full feed (only used when Browse full feed is enabled).

## `enableCompanyJobs` (type: `boolean`):

Collect live remote openings at specific companies by slug, e.g. "stripe", "lemon-io". Runs one filtered search per company. Off by default — turn on and add company slugs.

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

Company slugs to collect openings for (only used when Company jobs is enabled). Use the slug from the company's Himalayas URL, e.g. "stripe".

## `jobsPerCompany` (type: `integer`):

Cap the number of jobs collected per company.

## `enableScrapeByUrl` (type: `boolean`):

Collect full job records from explicit Himalayas job URLs (himalayas.app/companies/.../jobs/...). Off by default — turn on and paste URLs.

## `jobUrls` (type: `array`):

Himalayas job page URLs to collect (only used when Scrape by URL is enabled).

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new record is also delivered to this URL (CRM, Slack incoming webhook, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

Payload format for the webhook push: raw JSON record, or a Slack-friendly message.

## `proxyConfiguration` (type: `object`):

Proxy for Himalayas collection. Residential US proxies are recommended for the freshest results.

## Actor input object example

```json
{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer"
  ],
  "jobCountry": "",
  "worldwideOnly": false,
  "seniority": [],
  "employmentType": [],
  "jobSort": "relevant",
  "jobsPerQuery": 10,
  "fetchFullDetails": false,
  "enableBrowseFeed": false,
  "feedMaxJobs": 10,
  "enableCompanyJobs": false,
  "companySlugs": [],
  "jobsPerCompany": 10,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Full dataset for this run (every featureType).

## `overview` (type: `string`):

Core fields across features, including detailsFetched for search rows.

## `search` (type: `string`):

featureType=job_search only. One job = one row; full details are merged when "Fetch full details" is enabled.

## `browse_feed` (type: `string`):

No description

## `company_jobs` (type: `string`):

No description

## `scrape_by_url` (type: `string`):

No description

# 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 = {
    "enableJobSearch": true,
    "jobKeywords": [
        "software engineer"
    ],
    "jobCountry": "",
    "worldwideOnly": false,
    "jobsPerQuery": 10,
    "fetchFullDetails": false,
    "enableBrowseFeed": false,
    "feedMaxJobs": 10,
    "enableCompanyJobs": false,
    "jobsPerCompany": 10,
    "enableScrapeByUrl": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/himalayas-real-time-data-scraper").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 = {
    "enableJobSearch": True,
    "jobKeywords": ["software engineer"],
    "jobCountry": "",
    "worldwideOnly": False,
    "jobsPerQuery": 10,
    "fetchFullDetails": False,
    "enableBrowseFeed": False,
    "feedMaxJobs": 10,
    "enableCompanyJobs": False,
    "jobsPerCompany": 10,
    "enableScrapeByUrl": False,
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/himalayas-real-time-data-scraper").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 '{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer"
  ],
  "jobCountry": "",
  "worldwideOnly": false,
  "jobsPerQuery": 10,
  "fetchFullDetails": false,
  "enableBrowseFeed": false,
  "feedMaxJobs": 10,
  "enableCompanyJobs": false,
  "jobsPerCompany": 10,
  "enableScrapeByUrl": false
}' |
apify call b2b_leads/himalayas-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/himalayas-real-time-data-scraper"
        }
    }
}
```

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/1JAEYj7qCEGx3owIK/builds/lROTvcH7EKr32ZO4n/openapi.json