# MeroJob Nepal Jobs Scraper — Salaries, Skills & Deadlines (`bareezh_codes/merojob-nepal-jobs-scraper`) Actor

Extracts live job listings from merojob.com (Nepal's largest job portal) with employer details, salary, required skills, experience, education, deadline and apply link.

- **URL**: https://apify.com/bareezh\_codes/merojob-nepal-jobs-scraper.md
- **Developed by:** [Salman Bareesh](https://apify.com/bareezh_codes) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.
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

Scrape live job vacancies from **merojob.com**, Nepal's #1 job portal, capturing title, employer, salary, required skills, experience, education, deadline, and apply link — for recruitment agencies, HR teams, and labour-market researchers who need Nepali hiring data without writing and maintaining their own scraper.

### Why use the MeroJob Nepal Jobs Scraper?

merojob.com reports over 350 million page views and 4.1 million+ visits a month, 825K+ registered job seekers, and 38K+ employers — it is the dominant job board in a country whose economy is unusually dependent on formal and overseas labour placement. Individual developers already write ad-hoc scrapers against merojob.com's undocumented internal API (several public GitHub repos do exactly this) because there's no official public API — this actor replaces that brittle, hand-rolled script with a maintained one.

Main capabilities:

- Reads merojob.com's own JSON API (`api.merojob.com`), the same one the site's frontend uses — every job record already includes employer profile, salary, skills, education, and full description in one response.
- Filter by **keyword** (matched against title and description) and/or **category** (merojob.com's own job categories, e.g. "Accounting / Finance", "IT & Telecommunication").
- Toggle full description/requirements text on or off to keep the dataset lighter.
- Runs on the Apify platform, so you get scheduling (daily/weekly feeds), API and webhook access, and monitoring out of the box.

Typical use cases:

- **Recruitment & manpower agencies** — Nepal has one of the world's largest labour-export economies; agencies sourcing candidates for Gulf, Malaysia, or Korea placements can monitor new postings and salary comparables without checking the site manually every morning.
- **HR teams** at Nepali and multinational employers doing salary benchmarking against live market postings.
- **Job-aggregator and career-advice sites** pulling structured Nepali job data into their own product.
- **Labour-market researchers / NGOs** tracking Nepal employment trends by category, employer, and region.

### How to use the MeroJob Nepal Jobs Scraper

1. Click **Try for free** (or **Run**) on this actor's page.
2. Optionally set a **Keyword** (e.g. `"accountant"`) and/or a **Category** (e.g. `"IT & Telecommunication"`) to narrow results. Leave both blank to pull all live jobs.
3. Set **Max items** to cap how many jobs you want back.
4. Toggle **Include full description** off if you only need the structured fields (salary, skills, deadline, etc.) without the full description/requirements text.
5. Click **Start** and wait for the run to finish.
6. Open the **Dataset** tab and export your jobs as JSON, CSV, or Excel — or pull them programmatically via the **API** tab.

### How much will it cost to use the MeroJob Nepal Jobs Scraper?

You pay **$0.004 per result** — no subscription, no charge for anything else.

| Your Apify discount tier | Price per result | 1,000 results |
|---|---|---|
| Free | $0.004 | $4.00 |
| Bronze | $0.0035 | $3.50 |
| Silver | $0.003 | $3.00 |
| Gold | $0.0025 | $2.50 |
| Platinum / Diamond | $0.0025 | $2.50 |

Apify's free plan includes $5 of monthly credit. merojob.com typically has around 200 live jobs at any time, so a full daily refresh of the entire site (~$0.85 at the Free tier) comfortably fits inside the free credit with room to spare.

A run stops automatically once it has returned `maxItems` results or once it hits your run's maximum charge (Apify's pay-per-result cost cap) — so `maxItems` directly controls what a run can cost you.

### Input

All fields are optional — running the actor with an empty input (`{}`) scrapes the newest 100 live jobs across every category. See the **Input** tab for the full configuration schema.

| Field | Type | Default | Description |
|---|---|---|---|
| `keyword` | string | `""` (all) | Only return jobs matching this keyword, searched against title and description, e.g. `"accountant"`. |
| `category` | string | `""` (all) | Only return jobs in this merojob.com category, using the exact name shown on the site, e.g. `"Accounting / Finance"`, `"IT & Telecommunication"`, `"Sales and Marketing"`. |
| `maxItems` | integer | `100` | Maximum number of jobs to return. |
| `includeFullDescription` | boolean | `true` | Include each job's full description and requirements as plain text. Turn off for a lighter dataset. |

Example input for "the first 20 live IT & Telecommunication jobs, without full description text":

```json
{
  "category": "IT & Telecommunication",
  "maxItems": 20,
  "includeFullDescription": false
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. One item is produced per job, with the same keys every time (`null` when that data isn't available for a given posting). This is a real item from a live run of this actor (`tests/smoke_input.json`), with the long text fields trimmed for readability:

```json
{
  "jobId": "203621",
  "title": "Client Relations Executive",
  "slug": "client-relations-executive-6",
  "url": "https://merojob.com/client-relations-executive-6/",
  "employerName": "Merojob",
  "employerSlug": "merojobcom",
  "employerIndustry": "E-Commerce/ E-Business",
  "employerWebsite": "https://merojob.com",
  "categories": ["Sales / Public Relations", "Relationship"],
  "jobLevel": "Mid Level",
  "employmentType": ["Full Time"],
  "vacancies": 3,
  "offeredSalary": "NRs 25,000 - 28,000 Monthly",
  "salaryHidden": false,
  "experienceRequired": "Less than 2 years",
  "educationLevel": "Under Graduate (Bachelor)",
  "educationDescription": null,
  "skills": ["Communication", "Fast Learner", "Team Player", "Positive Attitude", "Accountable", "Client Relation", "Relationship-Building Skills", "B2B Sales"],
  "jobLocations": ["Minbhawan-31, Kathmandu"],
  "postedDate": "2026-09-13",
  "deadline": "2026-09-28T18:10:00Z",
  "hitCount": 152,
  "isPublished": true,
  "description": "Merojob is seeking a highly motivated and results-driven Client Relations Executive to join our dynamic team...",
  "requirements": "Bachelor's degree in Business Administration, Marketing, or a related field.\nAbout 2 years of experience in B2B sales...",
  "applyUrl": "https://merojob.com/client-relations-executive-6/"
}
```

#### Field reference

| Field | Description |
|---|---|
| `jobId`, `slug`, `url` | merojob.com's internal job ID, URL slug, and the job's public page |
| `title` | Job title |
| `employerName`, `employerSlug`, `employerIndustry`, `employerWebsite` | Hiring employer's profile on merojob.com |
| `categories` | merojob.com category tags for this job |
| `jobLevel` | Seniority level, e.g. "Mid Level", "Entry Level" |
| `employmentType` | e.g. `["Full Time"]` |
| `vacancies` | Number of open positions for this posting |
| `offeredSalary` | Human-readable salary string (currency, range, unit), `null` if the employer hid it |
| `salaryHidden` | `true` if the employer chose not to publish a salary |
| `experienceRequired` | Free-text experience requirement, e.g. "Less than 2 years" |
| `educationLevel`, `educationDescription` | Required education level and any extra detail |
| `skills` | Required/preferred skill tags |
| `jobLocations` | Work location(s) |
| `postedDate`, `deadline` | When the job was posted and when applications close |
| `hitCount` | Number of views the posting has received on merojob.com |
| `isPublished` | Whether the listing is currently live |
| `description`, `requirements` | Full job description and requirements as plain text; `null` if `includeFullDescription` is off |
| `applyUrl` | Link to apply — merojob.com handles the full application flow on this page |

### FAQ, disclaimers, and support

**Is this legal?** Yes. Every job this actor returns is a live, public vacancy that merojob.com itself displays to any visitor without a login. merojob.com's `robots.txt` places no `Disallow` rules on this data and its own Content-Signal explicitly sets `ai-input=yes`. This actor only reads merojob.com's own public API — no login, no CAPTCHA solving, no personal candidate data (only employer-published job postings).

**Why did my run return fewer than `maxItems` results?** merojob.com has roughly 200 live jobs at any given time (fewer if you narrow with `keyword`/`category`) — rerun with broader filters to see more, or check back later as new jobs are posted daily.

**Why is `offeredSalary` often `null`?** Many employers on merojob.com choose not to publish a salary; in that case `salaryHidden` is `true` and `offeredSalary` is `null`. This is the employer's choice, not a scraping gap.

**How fresh is the data?** As fresh as merojob.com itself — jobs are pulled live from the site's own API on every run.

**Can I filter by exact category?** Yes — set `category` to the exact category name shown on merojob.com (case-sensitive substring match against the job's own category list), e.g. `"Accounting / Finance"`.

#### Legal & compliance note

All data comes from merojob.com's own public API, which the site's frontend itself calls to render job listings to any visitor without requiring login or payment. This actor identifies itself with a descriptive `User-Agent` and paces its requests politely. It collects only employer-published job postings and public company information — no personal job-seeker data.

#### Limits & notes

- `api.merojob.com` is an undocumented internal API (not an officially published one), so its response shape could change without notice. This actor maps fields defensively and returns `null` for any field the API stops sending.
- merojob.com's total live-job corpus is modest (roughly 200 jobs) — treat this actor as a daily monitoring/refresh tool rather than a one-off big-data pull.

#### Support

Found a bug or have a feature request? Use the **Issues** tab on this actor's page. For programmatic access, see the **API** tab for ready-made code snippets in your language of choice.

# Actor input Schema

## `keyword` (type: `string`):

Only return jobs matching this keyword (searched against title and description), e.g. "accountant". Leave blank to return all jobs.

## `category` (type: `string`):

Only return jobs in this merojob.com category. Use the exact category name as shown on merojob.com, e.g. "Accounting / Finance", "IT & Telecommunication", "Sales and Marketing". Leave blank for all categories.

## `maxItems` (type: `integer`):

Maximum number of jobs to return. merojob.com has roughly 200 live jobs at any time, so the default comfortably covers a full daily pull.

## `includeFullDescription` (type: `boolean`):

Include each job's full description and requirements as plain text. Turn off for a lighter, faster-to-process dataset with just the structured fields.

## Actor input object example

```json
{
  "keyword": "",
  "category": "",
  "maxItems": 100,
  "includeFullDescription": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

One item per matching job vacancy

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("bareezh_codes/merojob-nepal-jobs-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("bareezh_codes/merojob-nepal-jobs-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 '{}' |
apify call bareezh_codes/merojob-nepal-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bareezh_codes/merojob-nepal-jobs-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/iPK3CBGruTjD4362f/builds/ZkohPygtNBFf67qSy/openapi.json