# Web Developer Jobs Scraper — LinkedIn, HN, RemoteOK + 7 More (`nomad-agent/web-dev-bundle`) Actor

Scrape developer jobs from 10 boards in one ~90s run: LinkedIn, RemoteOK, Remotive, WeWorkRemotely, Built In, JustJoin.it, NoFluffJobs, Hacker News, Y Combinator, WTTJ, InfoJobs, Tecnoempleo. URL-deduped, with structured salary, remote, seniority and skills. One bill, no child-actor fees.

- **URL**: https://apify.com/nomad-agent/web-dev-bundle.md
- **Developed by:** [Nomad.Dev](https://apify.com/nomad-agent) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 job 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/platform/actors/running/actors-in-store#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

## Web Developer Jobs Scraper — 10 Boards in One

One call, ten boards, one bill. Scrapes LinkedIn, RemoteOK/Remotive/WeWorkRemotely, Built In, JustJoin.it, NoFluffJobs, Hacker News "Who Is Hiring", Y Combinator, Welcome to the Jungle, InfoJobs and Tecnoempleo in a single ~80-second run, merges them, dedupes by URL and normalizes every posting onto one flat schema — structured salary, remote flag, seniority and skill tags, from every board alike.

No API keys, no login, no cookies, no proxy setup. Nothing else on the Store aggregates the developer-specific boards this way.

### What web developer jobs data does this scraper extract?

Each result is one flat JSON record per job posting, with the same structured columns for **every** board:

| Field | Type | Meaning |
|---|---|---|
| `source` | string | Which child board the record came from, e.g. `"justjoinit"` |
| `id` | string | Stable source-side identifier (`""` when the source has none) |
| `title` | string | Job title as posted |
| `company` | string | Hiring company / organisation |
| `location` | string | Location / duty station (may include remote hints) |
| `url` | string | Direct link to the posting (also the dedupe + delta key) |
| `postedAt` | string | Posting date where the source provides it, else `""` |
| `snippet` | string | Short description excerpt |
| `description` | string | Full description text where the source exposes one, else `""` |
| `salary` | string | Human-readable salary text (or composed from the numbers below), else `""` |
| `hiringContactName` | string|null | LinkedIn rows: person named as the job poster |
| `hiringContactTitle` | string|null | That person's LinkedIn headline |
| `hiringContactUrl` | string|null | Their LinkedIn profile URL |
| `salaryMin` | number|null | Lower bound of the pay range, normalized to a number |
| `salaryMax` | number|null | Upper bound of the pay range (null for single-figure/no pay) |
| `salaryCurrency` | string|null | Currency code (USD, EUR, GBP, PLN…) |
| `salaryPeriod` | string|null | One of `year`/`month`/`week`/`day`/`hour` |
| `isRemote` | boolean|null | True only for fully-remote; false hybrid/on-site; null if unknown |
| `remoteType` | string|null | `remote`/`hybrid`/`on-site` (keeps the hybrid nuance) |
| `seniority` | string|null | Experience level (e.g. `"Senior"`), where the source states it |
| `employmentType` | string|null | Contract/commitment type (e.g. `"Full-time"`, `"Contract"`) |
| `skills` | array|null | De-duplicated skill / technology tags, where the source has them |
| `companyLogo` | string|null | Company logo URL where provided |
| `companyUrl` | string|null | Company website/profile URL where provided |
| `companySize` | string|null | Company size label / employee count where provided |
| `industry` | string|null | Company industry / sector where provided |

**Uniform normalization.** The bundle derives `salaryMin/Max/Currency/Period`, `isRemote`/`remoteType`, `seniority`, `employmentType` and `skills` the same way for every board — from whichever structured field that child exposes, with a plain-code salary-text parser as a last-resort fallback (`ycombinator_was`, `hackernews`). Fields a source doesn't provide come back `null` (or `""` for the text fields); e.g. `linkedin`, `hackernews` and `tecnoempleo` surface no salary text, so their `salary` is `""` while `salaryMin/Max` may still be parsed where numbers exist.

#### Delta mode & recency

- **`onlyNewSinceLastRun`** — return only postings the bundle hasn't already delivered on a previous run (remembered by listing URL in a private key-value store on your own account). Already-seen rows are dropped *and not charged*. Ideal for a scheduled alert bot; the first run returns everything.
- **`postedWithinDays`** — only return postings no older than N days. Forwarded to each child under its own recency parameter (days, or hours for Hacker News — mapped automatically); the two sources without a recency input return their normal window. `0` disables it.

### How the bundle works

This is a **bundle Actor**: one endpoint that scrapes all 10 boards concurrently, maps every record onto one flat schema and **dedupes by URL** across boards. You can restrict the run to a subset with the `sources` input.

**One run, one bill.** Every board is scraped *inside this Actor's own run* — there are no child Actor runs, so you are never charged a second time by a downstream Actor. What you see on this page is the whole price. It also means one container instead of ten cold starts: a full 10-board run finishes in **about 80 seconds**.

**Developer-scoped by default.** Six of the ten boards (Built In, JustJoin.it, NoFluffJobs, Hacker News, Y Combinator, Tecnoempleo) list only tech roles. The four general-purpose boards (LinkedIn, RemoteOK/Remotive/WWR, InfoJobs, Welcome to the Jungle) are automatically scoped to developer roles in their own language, so a zero-config run returns engineers rather than each board's whole front page. Set `keyword` to override this with your own search term (e.g. `react`, `golang`, `platform engineer`).

### How to scrape web developer jobs with this Actor

1. Click **Try for free** / **Run** — no login to the target site, no cookies, no proxies to configure.
2. Adjust the input (keyword, filters, `maxItems`) or keep the defaults.
3. Run it and export the dataset as JSON, CSV or Excel, or read it over the [API](https://docs.apify.com/api/v2).

Run it from your own code:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nomad-agent/web-dev-bundle").call(run_input={"maxItems": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], "—", item["company"], item["url"])
```

Or a single HTTP call that runs the Actor and returns items in one response:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nomad-agent~web-dev-bundle/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"maxItems": 50}'
```

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `sources` | array | `["linkedin", "remote_boards", "builtin", "justjoinit", "nofluffjobs", "hackernews", "ycombinator_was", "wttj", "infojobs", "tecnoempleo"]` | Which boards to include. Leave empty to run the full default set. All boards are scraped inside this run and billed only at this Actor's price — no child-Actor fees. Fewer boards = a faster, cheaper run. |
| `keyword` | string | `""` | Free-text search term forwarded to every board that supports one. Leave empty and the four general-purpose boards fall back to a developer-scoped query in their own language; set it to search for a specific stack or role (`react`, `golang`, `platform engineer`). |
| `postedWithinDays` | integer | `0` | Only return postings no older than N days (mapped to each child's own recency param). `0` = no filter. |
| `onlyNewSinceLastRun` | boolean | `false` | Delta mode: return (and charge for) only listings not delivered on a prior run. Great for scheduled alert bots. |
| `maxItemsPerSource` | integer | `36` | Cap on items fetched from EACH child board before merge. |
| `maxItems` | integer | `360` | Hard cap on the merged, deduped output. Default is sources × `maxItemsPerSource` (the zero-config ceiling). Set `0` for no cap. |
| `cacheTtlSeconds` | integer | `1800` | How long to reuse results already fetched from a source instead of re-fetching. `0` = always fetch fresh. |
| `concurrency` | integer | `10` | How many boards to fetch at the same time. The default fetches them all at once, so a run takes as long as the slowest board rather than the sum. *(Advanced)* |
| `runTimeoutSecs` | integer | `300` | How long to wait for each source before giving up on it. Sources run in parallel, so this is a per-source ceiling, not a budget shared across them. *(Advanced)* |
| `apifyToken` | string (secret) | `""` | Leave empty — injected automatically on the Apify platform. Only set for local runs outside the platform. *(Advanced)* |

### Output example

```json
{
  "source": "justjoinit",
  "id": "upvanta-senior-full-stack",
  "title": "Senior Full Stack Developer",
  "company": "Upvanta",
  "location": "Poznań (Remote)",
  "url": "https://justjoin.it/job-offer/upvanta-senior-full-stack",
  "postedAt": "2026-06-26",
  "snippet": "We're looking for a senior full-stack engineer...",
  "description": "We're looking for a senior full-stack engineer to...",
  "salary": "B2B 22 000–28 000 PLN",
  "salaryMin": 22000,
  "salaryMax": 28000,
  "salaryCurrency": "PLN",
  "salaryPeriod": "month",
  "isRemote": true,
  "remoteType": "remote",
  "seniority": "Senior",
  "employmentType": null,
  "skills": ["React", "Node.js", "TypeScript"],
  "companyLogo": "https://justjoin.it/logos/upvanta.png",
  "companyUrl": null,
  "companySize": "50+",
  "industry": null
}
```

Every board returns the same shape; fields a source doesn't provide come back `null` (or `""` for text fields). A record from `linkedin`, `hackernews` or `tecnoempleo` has `"salary": ""`, with `salaryMin/Max` still populated where the source exposes numbers.

### Pricing

Pay per event: **$0.01 per Actor start** and **$0.003 per job returned** ($3 per 1,000 jobs). That is the entire cost — all 10 boards are scraped inside this run, so **no child Actor ever bills you on top**.

Zero-config run (defaults, all 10 boards): up to 360 merged, deduped jobs for at most **$1.09** ($0.01 start + 360 × $0.003). You only ever pay for **unique** jobs — a role cross-posted to three boards is charged once, and in `onlyNewSinceLastRun` mode a listing you already received is not returned or charged again. Cap the spend of any run with `maxItems`, or with Apify's per-run "Maximum cost" limit.

### Use cases

- Developer job boards that want breadth without 10 integrations
- Job-alert bots for frontend/backend/full-stack roles
- Hiring-market dashboards
- AI matching agents needing wide supply

### FAQ

**Is it legal to scrape web developer jobs?**
This Actor reads only publicly available job postings — data any visitor can see without logging in. No personal data behind authentication is touched. Review the target site's terms and your local regulations for your specific use case.

**Do I need an account on the target site?**
No. Postings are fetched from public pages/APIs — no login, cookies or session tokens.

**How fresh is the data?**
Every run fetches live listings. Results are cached for `cacheTtlSeconds` (default 30 min, set 0 to always hit the source live).

**How many jobs can I get?**
`maxItems` caps the run (set 0 for no cap). Most sources paginate from newest to oldest.

**Something broken or missing?**
Open an issue on the Actor's **Issues** tab — it is monitored and reliability fixes ship fast.

**Found it useful?**
Leaving a review on the Actor page genuinely helps other developers find it — and tells me which boards to add next.

### Integrations

Export the dataset as JSON, CSV or Excel, or read it straight from the [Apify API](https://docs.apify.com/api/v2). Works out of the box with Make, Zapier and n8n via their Apify integrations, can be called synchronously with `run-sync-get-dataset-items` from any backend, and is usable by AI agents through the [Apify MCP server](https://mcp.apify.com/).

### Related Actors

- [LinkedIn Jobs Scraper — No Login, No Cookies](https://apify.com/nomad-agent/linkedin-scraper)
- [Remote Jobs Scraper — RemoteOK Remotive WWR](https://apify.com/nomad-agent/remote-boards-scraper)
- [Built In Jobs Scraper — US Tech & Startup Jobs](https://apify.com/nomad-agent/builtin-scraper)
- [JustJoin.it Jobs Scraper — Polish Tech & IT Jobs](https://apify.com/nomad-agent/justjoinit-scraper)
- [NoFluffJobs Scraper — IT Jobs with Salaries](https://apify.com/nomad-agent/nofluffjobs-scraper)
- [Hacker News Who Is Hiring Scraper — HN Jobs](https://apify.com/nomad-agent/hackernews-scraper)
- [Y Combinator Jobs Scraper — Work at a Startup](https://apify.com/nomad-agent/ycombinator-was-scraper)
- [Welcome to the Jungle Jobs Scraper (WTTJ)](https://apify.com/nomad-agent/wttj-scraper)
- [InfoJobs Scraper — Ofertas de Trabajo y Empleo España](https://apify.com/nomad-agent/infojobs-scraper) — AI skill tags, structured salary, delta mode
- [Tecnoempleo Scraper — Spain IT & Tech Jobs](https://apify.com/nomad-agent/tecnoempleo-scraper)

***

**From the maker of [Oink](https://github.com/Exdenta/OinkAIJobSearch)** — an open-source, AI-powered job-search bot for Telegram that runs on these Actors. [Try the free bot](https://t.me/job_search_everyday_bot), get a managed instance at [oinkjobsearch.com](https://oinkjobsearch.com), or browse the [full catalog of 50+ Actors](https://apify.com/nomad-agent).

# Actor input Schema

## `sources` (type: `array`):

Which boards to include. Leave empty to run the full default set. All sources are scraped inside this Actor's own run and billed only at this bundle's pricing — no separate child-actor fees. Fewer sources means a faster, cheaper run.

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

Search term forwarded to every board that supports one — e.g. "react", "golang", "platform engineer". Leave empty and the four general-purpose boards (LinkedIn, RemoteOK/Remotive/WWR, InfoJobs, Welcome to the Jungle) are automatically scoped to developer roles in their own language, so you get engineers instead of each board's whole front page. The six tech-only boards always return their full feed.

## `postedWithinDays` (type: `integer`):

Recency filter: only return postings no older than this many days. Forwarded to each child under its own recency parameter (most take days, Hacker News takes hours — mapped automatically). Two sources with no recency input (Y Combinator, WTTJ) return their normal window. Listings with no known posting date are kept, not dropped. Set 0 to disable.

## `onlyNewSinceLastRun` (type: `boolean`):

Delta / monitoring mode: return only postings this bundle has NOT already delivered on a previous run that also had this flag on. The bundle remembers every listing URL it returned (in a private key-value store on your own Apify account) and, on later runs, drops — and does not charge its per-result fee for — anything you already received. The first run always returns everything. Leave off for a full snapshot each run; turn on for a scheduled (e.g. daily) alert bot that should surface only fresh roles.

## `maxItemsPerSource` (type: `integer`):

Cap on items fetched from EACH child board before merging. Raise it for a deeper sweep of every board; the merged total is still bounded by 'Max items (total)' below.

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

Hard cap on the merged, deduped output — and therefore on what you pay, since this Actor charges per unique job returned. Default (360) is sources × 'Max items per source'. Set 0 to remove the cap — cost then scales with every source's raw output.

## `cacheTtlSeconds` (type: `integer`):

How long to reuse results already fetched from a source instead of fetching again. Set 0 to always fetch fresh data.

## `concurrency` (type: `integer`):

How many source boards to fetch at the same time. The default fetches them all at once, so a run takes as long as the slowest board rather than the sum.

## `runTimeoutSecs` (type: `integer`):

How long to wait for each source before giving up on it. Sources run in parallel, so this is a per-source ceiling, not a budget shared across them.

## `apifyToken` (type: `string`):

Leave empty — injected automatically when this Actor runs on the Apify platform. Only set this when running the code outside the platform, e.g. on your own machine.

## Actor input object example

```json
{
  "sources": [
    "linkedin",
    "remote_boards",
    "builtin",
    "justjoinit",
    "nofluffjobs",
    "hackernews",
    "ycombinator_was",
    "wttj",
    "infojobs",
    "tecnoempleo"
  ],
  "postedWithinDays": 0,
  "onlyNewSinceLastRun": false,
  "maxItemsPerSource": 36,
  "maxItems": 360,
  "cacheTtlSeconds": 1800,
  "concurrency": 10,
  "runTimeoutSecs": 300
}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("nomad-agent/web-dev-bundle").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("nomad-agent/web-dev-bundle").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 nomad-agent/web-dev-bundle --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nomad-agent/web-dev-bundle",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/m6h2Dtyzxd2C0biiP/builds/l0OANyf12CAb5IgXu/openapi.json