# Himalayas Jobs Lookup: Remote Postings by Keyword & Category (`accountable_eel/himalayas-jobs-lookup`) Actor

Run keyword or category searches against Himalayas' own public remote-jobs feed and get one row per posting: title, company, salary, seniority, locations, full description, apply link. No login. Pay per posting returned; an empty search is free.

- **URL**: https://apify.com/accountable\_eel/himalayas-jobs-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 job posting returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Himalayas Jobs Lookup — Remote Postings by Keyword & Category

You write a keyword or a Himalayas category name — `product designer`, `Data Science` — one per
line, or leave a line blank, and this actor pages Himalayas' own public remote-jobs feed and
returns one clean row per matching posting: title, company, salary when it's disclosed, seniority,
location restrictions, the full description, and a permanent apply link.

No login, no API key, no anti-bot. It calls the same JSON endpoint (`himalayas.app/jobs/api`) the
site's own job list calls in your browser.

### Who it's for

The accountable\_eel catalogue sells company and hiring intelligence columns for outbound and
recruiting. Each actor takes a list of identifiers — domains, company slugs, and here, job
searches — and returns one flat, stably-named row per result: the shape a Clay table, an n8n
workflow, or an AI agent can consume without post-processing. Pricing is pay-per-event: a fraction
of a cent for a row you actually got, and nothing at all for a search that finds nothing. No seat
licence, no monthly minimum, no credit system to decode.

This actor is the wide-net, remote-only end of that catalogue's job-search pair. Its sibling
`linkedin-jobs-search-lookup` covers LinkedIn's general job board, on-site and remote alike; this
one is Himalayas — a board that lists remote roles exclusively, so every row it returns is already
a remote posting by construction, no filtering required to get there.

### Why this one

- **Himalayas' feed has no server-side search, and this actor says so rather than pretending
  otherwise.** `search`, `q`, `keyword`, `category`, `seniority` and `employmentType` were all
  tried as query parameters against the live endpoint on 2026-08-24 and every one came back with
  the identical first page as no parameters at all — this is a firehose feed of the newest
  postings, not a query API. So every filter this actor offers, including your own search line, is
  applied here, client-side, after paging the feed newest-first. Nothing is forwarded upstream and
  silently ignored.
- **A keyword search is bounded, on purpose.** With no server-side filter, finding "engineer" jobs
  means scanning the live feed and testing each posting. This actor scans up to 100 pages (2,000
  of the newest postings) per search line before giving up — enough to catch anything posted
  recently, without one obscure keyword turning into a walk through Himalayas' entire ~104,000-job
  archive. `pagesScanned` and `truncated` on every row say exactly how far this run looked, so a
  thin result reads as "nothing recent matched" rather than a silent bug.
- **You are never billed for the same posting twice.** Every posting is deduplicated by an ID
  derived from its own permalink, across the pages of one search and, by default, across every
  search line in the run — so two overlapping searches that both surface the same role are charged
  once, not twice.
- **The full description ships free.** Himalayas' feed already includes each posting's full text —
  there's no separate detail page to fetch and no extra charge for it, unlike a board that only
  gives you a teaser on the search card.
- **Search a keyword or a category, in the same box.** Himalayas tags every posting with both
  granular tags (`Python-Developer`) and broader department names (`Data Science`, `Developer`).
  Type either kind of term and it matches.

### What you get

One row per job posting by default. (Turn off "One row per job posting" in the Input tab to get one
row per *search* instead, with the whole posting list nested in `jobs`.) Every row carries these
fields:

| Field | Type / format | Description |
| --- | --- | --- |
| `query` | text | The search line you passed in, unchanged. |
| `found` | boolean | `true` if the search returned at least one posting after your filters. `false` rows are never charged. |
| `status` | text | `OK`, or `BLOCKED` if Himalayas' API didn't respond with its usual JSON. |
| `searchTerm` | text | The search line actually used, or `null` for a blank line (no filter — newest jobs). |
| `jobCount` | number | How many postings this search returned after filtering — exactly what you're charged for. |
| `pagesScanned` | number | How many 20-posting feed pages this search actually paged through. |
| `truncated` | boolean | `true` if the page-scan cap or your "Most postings to return" limit was hit before the feed ran out. |
| `jobs` | array | The full posting list. Present in every row; it's what gets expanded into separate rows in "one row per posting" mode. |
| `jobId` | text | Derived from the posting's own permalink (`companySlug/jobSlug`) — Himalayas has no separate ID field, so this is what deduplication keys on. |
| `title` | text | Job title, as Himalayas has it. |
| `companyName` | text | Hiring company. |
| `companySlug` | text | The company's Himalayas URL slug. |
| `companyLogo` | image | Company logo URL, when Himalayas has one. |
| `employmentType` | text | One of Full Time, Part Time, Contractor, Intern, Temporary. |
| `seniority` | array | One or more of Entry-level, Mid-level, Senior, Manager, Director, Executive. |
| `salaryMin` / `salaryMax` | number | Disclosed pay range. Both `null` on roughly half of postings — Himalayas simply doesn't require pay disclosure. |
| `salaryPeriod` | text | `annual`, `hourly`, or `monthly`. |
| `currency` | text | e.g. `USD`, `EUR`. `null` when no salary is disclosed. |
| `salaryText` | text | The pay range formatted as one readable line, e.g. "USD 99,375–160,000/year". `null` when undisclosed. |
| `locationRestrictions` | array | Countries hiring is restricted to, e.g. `["United States"]`. |
| `worldwide` | boolean | `true` when `locationRestrictions` is empty — Himalayas' own way of saying "open to anyone, anywhere". |
| `categories` | array | Granular Himalayas tags, e.g. `["Python-Developer", "Backend-Engineer"]`. |
| `parentCategories` | array | Broader department names, e.g. `["Developer"]`. Missing on roughly half of postings — Himalayas doesn't always set it. |
| `publishedAt` | date (ISO) | When the posting went live. |
| `expiresAt` | date (ISO) | When the posting is set to expire. |
| `applicationLink` | link | Permanent public link to apply. |
| `summary` | text | Himalayas' own short teaser for the posting. |
| `description` | text | The full posting text, as plain text. |
| `scrapedAt` | date (ISO) | When this actor fetched the row. |

A search that returns no postings — after your filters, or because nothing recent matched — comes
back as a single `found: true`, `jobCount: 0` row rather than a miss: the search legitimately ran
and answered the question, so it costs nothing but isn't reported as a failure either.

### Pricing

- **Job posting returned**: $1 per 1,000 job postings

Plus a $0.00005 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

You're charged **per posting returned**, not per search — a search that returns 12 postings costs
twelve, and a search that returns none (whether because your filters matched nothing, or because
the line was blank and asked for a plain feed) costs nothing. "Most postings to return per search"
is your budget control, so a five-search run at the default 50 costs at most 250 postings' worth.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `searches` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~himalayas-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"searches":["product designer",""]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "searches": [
    "product designer",
    ""
  ]
}
```

One search per line. Write a keyword ("product designer"), a Himalayas category name ("Data Science"), or leave the line blank to get the newest remote jobs with no filter at all. Accepted formats: product designer, Data Science, customer support.

### Output

One row per item, for example:

| query | found | status | searchTerm | jobCount | pagesScanned | truncated | jobs | jobId | title | companyName | companySlug | companyLogo | employmentType | seniority | salaryMin | salaryMax | salaryPeriod | currency | salaryText | locationRestrictions | worldwide | categories | parentCategories | publishedAt | expiresAt | applicationLink | summary | description | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Data Science | true | OK | Data Science | 50 | 89 | true | \<all postings found (full list)> | claritas-rx/associate-business-analyst | Associate Business Analyst | Claritas Rx | claritas-rx | https://cdn-images.himalayas.app/xxxflftzns5p6tilkwo32t74eyzq | Full Time | \["Mid-level"] | 60000 | 70000 | annual | USD | USD 60,000–70,000/year | \["United States"] | false | \["Delivery","Computer-Software","Data-Analyst","Business-Analysis","Implementation-Specialist","Associate-Business-Analyst","Junior-Business-Analyst","Associate-Analyst","Business-Analyst"] | \["Data Science","Customer Service"] | 2026-08-31T05:25:42.000Z | 2026-10-30T05:25:41.000Z | https://himalayas.app/companies/claritas-rx/jobs/associate-business-analyst | Who We AreClaritas Rx uses AI and predictive modeling to help rare disease and specialty brands remove the barriers that keep patients from accessing and staying on the treatments they need. | Who We Are Claritas Rx uses AI and predictive modeling to help rare disease and specialty brands remove the barriers that keep patients from accessing and staying on the treatments they need. By uniting the most complete view of the patient journey with purpose-built technologies, we predict and resolve access challenges before they disrupt care, combining advanced analytics, real-world data, AI, and CRM capabilities to increase start and refill rates, reduce abandonment, and improve brand performance. Our mission is to ensure patients with chronic, life-threatening diseases receive the support that enables the greatest benefit from their therapy. Simply put, our promise is progress for every patient journey. This is the opportunity to help shape a first-in-industry digital health solution alongside a team of mission-driven professionals. We were named one of Inc.'s Best Workplaces in 2025 and recognized on the Inc. 5000 list for two consecutive years (2025 and 2026), and our team genuinely respects and supports each other. We thrive on being fast-paced, innovative, and results-driven, and our employees enjoy a flexible, collaborative work environment, unlimited PTO, stock options, and a growing set of tools and technology to drive innovation for our customers. The Position Our Ascend® platform represents the next generation of our delivery capability — a standardized, scalable implementation model that enables faster, higher-quality client onboarding across our specialty pharmacy data ecosystem. The Associate Business Analyst is a technical executor of the Ascend platform configuration. The top expectation of this role is the ability to lead and manage spec negotiations with data partners — ensuring that inbound and outbound data file specifications are aligned with the Ascend data model before configuration work begins. This requires both deep technical fluency in specialty pharmacy data structures and the communication skills to drive data partners toward compliant, complete specifications without compromising go-live timelines. Working from the Configuration Blueprint produced by the Delivery Director, the Associate BA owns all data mapping, platform configuration, and internal quality assurance before any client-facing testing begins. The Associate BA operates as a critical resource within the Ascend implementation team — interfacing with Engagement Managers, Delivery Directors, and Customer Engineering — and is expected to communicate capacity constraints proactively given the demands of a multi-client portfolio. As a member of the Delivery and Operations team, the Associate BA is responsible for executing implementation configuration work, conducting rigorous internal QA, and ensuring that nothing advances to UAT without sign-off. The Associate BA is the standard-vs-custom decision support layer for data: identifying when client requests require escalation to Product or Customer Engineering versus when they can be addressed within the standard data model. This role is primarily remote with occasional travel requirements. Key Accountabilities Data Partner Spec Negotiation ★ Primary Accountability Lead spec negotiations with specialty pharmacy and other data partners to ensure inbound and outbound file specifications are fully aligned with the Ascend data model before configuration begins — this is the single most critical function of the role Review partner-submitted data specifications for completeness, field-level accuracy, and model alignment; document gaps and drive resolution directly with the data partner Negotiate field mappings, list-of-values (LOVs), file formats, and delivery cadences with data partners, escalating to the Engagement Manager only when partner alignment cannot be achieved at the working level Validate test files against finalized specifications and flag discrepancies before data enters the pipeline; maintain a clear record of spec versions and sign-off status across all active partners Translate data partner constraints into actionable decisions for the implementation team — identifying what can be resolved through configuration, what requires a spec exception, and what must route to Customer Engineering Platform Configuration & Data Mapping Own all platform configuration work: data mapping, configuration tooling, business logic implementation, and front-end reporting setup — all driven by the Configuration Blueprint received from the Delivery Director Review data specifications produced in collaboration with the Engagement Manager; proactively flag data model mismatches or gaps prior to configuration work beginning Load data into the pipeline using configuration tooling once specifications are finalized and signed off by relevant stakeholders Collaborate with Customer Engineering on the handoff of data mapping for standard data model onboarding; provide CE with the context needed for custom build workstreams Internal QA & Quality Standards Conduct internal QA testing of all configuration work prior to partner or client-facing testing — nothing advances to UAT without BA sign-off Track and resolve defects identified during internal QA and UAT for all configuration-related issues Perform quality control procedures to assure configurations and data quality meet acceptance criteria prior to go-live Develop and maintain QA documentation, test case frameworks, and checklists that support repeatable, auditable testing across implementations Escalation & Non-Standard Request Routing Identify whether client requests fall within the standard Ascend data model, require configuration adjustment, or require escalation — to Product for roadmap consideration or to Customer Engineering for custom build Document and route non-standard requests with clear business need descriptions and technical context so that Product and CE can act without re-scoping Conduct change impact analysis to assess how updates or non-standard requests may affect system performance and configuration decisions Cross-Functional Coordination Consult with Engagement Managers on data partner specs, testing timelines, and UAT scheduling to ensure internal readiness gates are met Coordinate with Delivery Director on receipt and interpretation of the Configuration Blueprint — the primary work input for each implementation Report blockers, capacity constraints, and escalations to the Engagement Manager proactively; given a typical 1-BA-to-many implementations ratio, early communication of bandwidth risks is a core accountability Support the Delivery Director and Customer Success with UAT business validation for configuration-related questions Process, Documentation & Knowledge Management Facilitate schema normalization of system databases; maintain data dictionaries and file inventories across customer applications Consults with cross-functional teams to document business requirements, operating procedures, issue resolution processes, and platform configurations that enable efficient implementation Develop and maintain an operating playbook that details best practices for configuration sequencing, data partner onboarding, and documentation requirements Write clear, detailed procedures for internal training and be able to train other Business Analysts as the team scales Support creation and ongoing maintenance of standard UAT test script templates for core Ascend use cases in partnership with the Delivery Director Who You Are Skills & Knowledge: Ability to lead data partner spec negotiations — driving alignment on file specifications, field mappings, and LOVs across multiple external partners simultaneously Excellent written and oral communication — able to document complex data relationships clearly for both technical and non-technical audiences Ability to prioritize, organize, and execute multiple tasks simultaneously with rigorous attention to detail across a high-volume implementation portfolio A creative approach to operational problem solving and a relentless passion for quality Knowledge of data management in specialty biotech and/or operations in reimbursement call centers or specialty pharmacies Familiarity with healthcare data sources — transactional, clinical, and behavioral — including specialty pharmacy data file types (patient demographics, dispense, status, inventory) Understanding of standard implementation lifecycle frameworks: UAT facilitation, defect triage, QA gating, and go-live readiness Ability to exercise judgment within broadly defined practices and policies when selecting methods and techniques for configuration decisions Education & Experience Required: Bachelor's degree from a 4-year university Relevant experience in an operations role at a biopharmaceutical manufacturer, reimbursement call center, specialty pharmacy, or data management company Proficient in Microsoft Excel and other analytic tools — specifically data comparison, conditional formulas, data summary, and conversion Functional knowledge of Microsoft Office suite (Word, PowerPoint, Excel) Background and experience with the Business Analysis toolkit including systems development lifecycles, problem solving and root cause analysis methods, and the ability to document business process models Demonstrated ability to manage deliverables across multiple concurrent implementations or client programs Preferred: Experience with specialty pharmacy data file specifications, SFTP workflows, and data onboarding processes Academic training in public health, business administration, and/or operations research Case management experience in a reimbursement call center or specialty pharmacy Familiarity with project management tools such as Smartsheet, JIRA, or Confluence Familiarity with Google Docs, workflow diagram tools, web-based software systems, and relational databases Experience working within a structured RACI model or implementation team framework Join Us We are seeking to add new expertise and perspective to our strong team of experienced professionals. We aspire to a culture of accelerated professional development through: shared learning and collaboration; a respectful and fun work environment; and employee empowerment through the effective use of technology and tools. We are a highly collaborative team and prioritize opportunities to connect in person. For employees within a reasonable driving distance of each other, we host regional town hall gatherings approximately every other month. These sessions give our teams a chance to come together, share updates, and strengthen relationships beyond day-to-day work. In addition to our great environment, we offer a competitive salary of $60,000 to $70,000 and benefits package and the opportunity to make a significant impact on a first-in-industry digital health solution. Please send a cover letter along with your resume when applying to the position of interest. Claritas Rx embraces diversity, equality, and transparency. We are committed to building a team that comprises a variety of backgrounds, perspectives, and talents. We believe the more inclusive we are, the better we are. Join us and discover what it feels like to be part of an environment that rewards ingenuity, risk taking and smart work. It's time to fall in love with what you do! At Claritas Rx , protecting our candidates is a top priority. If you're applying for a role with us, please note: •All legitimate opportunities are posted first on ClaritasRx.com. Check there before trusting external listings. • We believe in meaningful interviews: offers never come after just one phone call or form. Expect multiple video calls to get to know you. • We never ask for fees or payments of any kind during the hiring process. • Our People Operations Team will handle your onboarding, and all equipment comes directly from us—no purchases required. Learn more about how to spot recruitment scams and protect yourself - FBI warning: Claritas Rx is committed to transparency, integrity, and a safe hiring experience for every candidate. Learn more Originally posted on Himalayas | 2026-08-31T06:01:46.151Z |

A miss comes back as a row with `"found": false` and is never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~himalayas-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"searches":["product designer",""]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~himalayas-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"searches":["product designer",""]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~himalayas-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"searches":["{{search}}"]}`, mapping the row's search into the `searches` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Himalayas Jobs Lookup | Apify" — the agent will find and run this actor.

# Actor input Schema

## `searches` (type: `array`):

One search per line. Write a keyword ("product designer"), a Himalayas category name ("Data Science"), or leave the line blank to get the newest remote jobs with no filter at all. Accepted formats: product designer, Data Science, customer support. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `maxJobsPerQuery` (type: `integer`):

Himalayas hands out 20 postings per feed page. You pay per posting returned, so this is also your budget control. Capped at 1,000.

## `titleKeywords` (type: `array`):

Optional. On top of your search line above, keep only postings whose TITLE contains at least one of these words. Case doesn't matter and partial words work. Leave empty to keep every matching role.

## `excludeTitleKeywords` (type: `array`):

Optional. Drop any role whose title contains one of these words — e.g. "intern", "senior". Applied after the include list above.

## `locations` (type: `array`):

Optional. Match against the countries a posting restricts hiring to — e.g. "United States", "Germany". Type "worldwide" to match postings with no location restriction at all.

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

Optional. Himalayas tags each posting with one or more of: Entry-level, Mid-level, Senior, Manager, Director, Executive. Partial matches work, so "senior" also catches "Senior".

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

Optional. Himalayas tags each posting with one of: Full Time, Part Time, Contractor, Intern, Temporary.

## `salaryDisclosedOnly` (type: `boolean`):

Roughly half of Himalayas postings don't state a salary at all. Turn this on to keep only the ones that do.

## `skipDuplicateJobs` (type: `boolean`):

On by default. Overlapping search lines routinely surface the same posting — with this on, each one is returned, and billed, exactly once per run.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each job posting found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "searches": [
    "product designer",
    ""
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "maxJobsPerQuery": 50,
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "locations": [],
  "seniority": [],
  "employmentType": [],
  "salaryDisclosedOnly": false,
  "skipDuplicateJobs": true,
  "columns": [
    "searchTerm",
    "jobCount",
    "pagesScanned",
    "truncated",
    "jobs",
    "jobId",
    "title",
    "companyName",
    "companySlug",
    "companyLogo",
    "employmentType",
    "seniority",
    "salaryMin",
    "salaryMax",
    "salaryPeriod",
    "currency",
    "salaryText",
    "locationRestrictions",
    "worldwide",
    "categories",
    "parentCategories",
    "publishedAt",
    "expiresAt",
    "applicationLink",
    "summary",
    "description"
  ],
  "expandRows": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searches": [
        "product designer",
        ""
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "locations": [],
    "seniority": [],
    "employmentType": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/himalayas-jobs-lookup").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 = {
    "searches": [
        "product designer",
        "",
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "locations": [],
    "seniority": [],
    "employmentType": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/himalayas-jobs-lookup").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 '{
  "searches": [
    "product designer",
    ""
  ],
  "includeKeywords": [],
  "excludeKeywords": [],
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "locations": [],
  "seniority": [],
  "employmentType": []
}' |
apify call accountable_eel/himalayas-jobs-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/himalayas-jobs-lookup"
        }
    }
}
```

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/7hlAeoNQmIP3hCbe0/builds/b8tIHJRzfXDnCe7a0/openapi.json
