# 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:** 3 total users, 1 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 concurrently, merges them, removes exact and cross-source duplicate postings, and normalizes every posting onto one flat schema. Multi-keyword, geographic, remote, experience and title-exclusion filters are translated to each board's native inputs. Optional BYOK AI matching ranks the results for a candidate.

No API keys, login, cookies or proxy setup are required for scraping. A provider key is needed only when you opt into candidate matching. Nothing else on the Store aggregates the developer-specific boards this way.

> **Claude / Codex skill to describe and setup this actor: [SKILL.md](https://github.com/Exdenta/OinkAIJobSearch/blob/main/skill/web-dev-bundle/SKILL.md)**

### 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 |
| `matchScore` | number|null | AI candidate-fit score from 0–10 when `candidateProfile` is supplied |
| `matchReason` | string|null | Evidence-based reason for the score |
| `mismatchReason` | string|null | Most important material mismatch, if any |
| `rankingModel` | string|null | Provider/model used for matching |

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

#### Candidate matching

Set `candidateProfile` to a resume/profile summary and optionally add `preferences` plus `minimumMatchScore`. Supply an Anthropic, Mistral or OpenAI API key. The model evaluates explicit requirements, skills, seniority, geography/work authorization, compensation and exclusions in context; no hardcoded keyword scoring rules are used. Results are returned best-first with `matchScore`, `matchReason`, `mismatchReason` and `rankingModel`.

The profile and API key are never written to the dataset or `RUN-SUMMARY`. If the selected provider rejects the key or returns incomplete scoring JSON, the run fails clearly instead of silently returning unranked results.

### 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 deduplicates exact URLs plus corroborated cross-source copies using normalized title/company/location with matching description or textual URL identity. The richer copy is retained. You can restrict the run to a subset with `sources`.

**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 boards list only tech roles. The four general-purpose boards are automatically scoped to developer roles in their own language. Use `keywords` for several searches. Array-capable sources receive the full list; single-query sources fan out with their cap divided fairly. Built In and NoFluffJobs expose categories rather than free-text search, so their `RUN-SUMMARY.querySupport` says `unsupported` instead of falsely claiming the query was applied. Their category requests are also divided fairly to prevent the first category from consuming the entire cap.

**Observable and honest.** Every completed run writes a machine-readable `RUN-SUMMARY` key-value-store record with per-source request, raw, filtered and delivered counts, query support and errors. One failed source produces a `partial` run with the others preserved. An all-source outage or bundle/matching failure fails the run; it is never disguised as a successful diagnostic row.

### 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`). |
| `keywords` | array | `[]` | Preferred multi-query input. Single-query sources fan out fairly; array-aware sources receive all terms together. Overrides `keyword` when non-empty. |
| `location` | string | `""` | LinkedIn location, JustJoin.it city, and InfoJobs/Tecnoempleo province. |
| `countryCodes` | array | `[]` | ISO two-letter country codes for WTTJ. |
| `remoteOnly` | boolean | `false` | Use native source filters where available, then keep only normalized fully-remote rows. |
| `titleExclude` | array | `[]` | Title phrases excluded on sources with native support. |
| `experienceLevels` | array | `[]` | JustJoin.it levels such as `junior`, `mid`, `senior`. |
| `maxExperienceYears` | integer | unset | WTTJ maximum required experience. |
| `includeDetails` | boolean | `true` | Fetch full descriptions/details on supported sources, including JustJoin.it and WTTJ. |
| `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. |
| `candidateProfile` | string | `""` | Optional resume/profile summary that enables AI matching. |
| `preferences` | string | `""` | Optional prose or JSON with role, geography, salary and exclusion preferences. |
| `minimumMatchScore` | integer | `0` | Keep scores at or above this 0–10 threshold; `0` keeps all ranked results. |
| `aiProvider` / `aiModel` | string | inferred / low-cost default | Candidate-matching provider and optional model override. |
| `anthropicApiKey` / `mistralApiKey` / `openaiApiKey` | secret | `""` | Supply the key matching the selected provider. Required only for candidate matching. |
| `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,
  "matchScore": 9,
  "matchReason": "Strong React, TypeScript and senior full-stack fit; fully remote.",
  "mismatchReason": null,
  "rankingModel": "anthropic:claude-haiku-4-5-20251001"
}
```

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`):

Legacy single search term. Prefer Keywords below for broader searches. Forwarded only to boards that support free-text search; RUN-SUMMARY explicitly marks category-only boards instead of pretending they honored it.

## `keywords` (type: `array`):

One or more searches, e.g. React, TypeScript, frontend engineer. Array-aware boards receive all terms together; single-query boards are queried once per term with the per-source cap divided fairly. Leave empty for the bundle's developer-role defaults.

## `location` (type: `string`):

Native geographic filter where supported: LinkedIn location, JustJoin.it city, and InfoJobs/Tecnoempleo province. Use Country codes for WTTJ.

## `countryCodes` (type: `array`):

ISO two-letter country codes forwarded to Welcome to the Jungle, e.g. ES, FR, DE.

## `remoteOnly` (type: `boolean`):

Ask every source with a native remote filter for remote roles, then enforce the normalized isRemote=true field across the merged output. Hybrid and unknown arrangements are excluded.

## `titleExclude` (type: `array`):

Forward these exclusions to boards that support them, e.g. intern, sales, unpaid.

## `experienceLevels` (type: `array`):

Native JustJoin.it experience levels such as junior, mid, senior, manager or c\_level.

## `maxExperienceYears` (type: `integer`):

Keep WTTJ postings that require at most this many years. Leave empty to disable.

## `includeDetails` (type: `boolean`):

Fetch full descriptions/details wherever the child source supports them, including JustJoin.it and WTTJ. Disable for a faster, lighter listing-only run.

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

## `candidateProfile` (type: `string`):

Paste a resume/profile summary with skills, seniority, location, work authorization and must-haves. When supplied, every job receives matchScore (0-10), matchReason and mismatchReason from an LLM. Requires one API key below. Matching is prompt-driven; the bundle does not use brittle keyword score rules.

## `preferences` (type: `string`):

Optional prose or JSON describing preferred roles, locations, salary, exclusions and hard constraints.

## `minimumMatchScore` (type: `integer`):

When candidate matching is enabled, omit jobs scored below this 0-10 threshold. Set 0 to keep all jobs ranked best-first.

## `aiProvider` (type: `string`):

Provider used only for candidate matching. If omitted, inferred from the supplied key.

## `aiModel` (type: `string`):

Optional provider model ID. Leave empty for the bundle's low-cost default.

## `anthropicApiKey` (type: `string`):

Secret Anthropic key used only when candidate matching selects Anthropic.

## `mistralApiKey` (type: `string`):

Secret Mistral key used only when candidate matching selects Mistral.

## `openaiApiKey` (type: `string`):

Secret OpenAI key used only when candidate matching selects OpenAI.

## `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"
  ],
  "keywords": [
    "react",
    "typescript",
    "frontend engineer"
  ],
  "location": "Madrid",
  "countryCodes": [
    "ES",
    "FR"
  ],
  "remoteOnly": false,
  "titleExclude": [],
  "experienceLevels": [],
  "includeDetails": true,
  "postedWithinDays": 0,
  "onlyNewSinceLastRun": false,
  "minimumMatchScore": 0,
  "maxItemsPerSource": 36,
  "maxItems": 360,
  "cacheTtlSeconds": 1800,
  "concurrency": 10,
  "runTimeoutSecs": 300
}
```

# Actor output Schema

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

No description

## `runSummary` (type: `string`):

Per-source status, query support, request/raw/filtered/delivered counts, errors, filters, dedupe and truncation totals. Never contains API keys or candidate-profile text.

# 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/actors/m6h2Dtyzxd2C0biiP/builds/evqY8nHrskJE7iiSS/openapi.json