# JobServe Scraper (Remote IT Jobs via Jobicy) (`crawlerbros/job-serve-scraper`) Actor

Scrape remote IT and tech job listings from Jobicy's public API. Search by keyword, industry sector, geographic region, job level, and salary range. No authentication required.

- **URL**: https://apify.com/crawlerbros/job-serve-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## JobServe Scraper (Remote IT Jobs)

Scrape remote IT and technology job listings with salary data, sector classification, geographic filtering, and seniority levels. This actor provides rich job metadata including salary ranges, company information, job descriptions, and apply URLs — with no authentication or API key required.

### Data Source

This actor uses the **Jobicy public API** (`https://jobicy.com/api/v2/remote-jobs`), which provides free, open access to a curated list of remote IT and tech jobs worldwide. Jobicy focuses on quality remote positions across development, DevOps, data science, design, marketing, and more.

**Note on JobServe:** The original JobServe (jobserve.com) is a UK-focused IT job board that requires JavaScript rendering and has no public API. Jobicy is used as a freely accessible equivalent covering the same IT/tech job niche with superior data quality (salary ranges, seniority levels, sector classification) and no authentication barriers.

### Features

- **Search mode** — find jobs by keyword, industry sector, geographic region, and job level
- **Get Job mode** — look up specific jobs by their Jobicy ID or slug
- Full salary range data (min, max, currency, period)
- Geographic filtering across 20+ regions (USA, UK, Europe, worldwide, etc.)
- Industry/sector filtering (Development, DevOps, Data, Design, Marketing, and more)
- Seniority level filtering (Junior, Mid, Senior, Lead, Manager, Director)
- Job type filtering (Full-time, Part-time, Contract, Freelance)
- Clean plain-text job descriptions (HTML stripped)
- No API key, proxy, or account required — runs on the Apify free plan

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | `search` (default) or `getJob` — **required** |
| `query` | string | Keyword search (e.g., `python developer`, `react`, `AWS`) |
| `geo` | select | Geographic region (USA, UK, Europe, Worldwide, etc.) |
| `location` | string | Additional text filter on location field |
| `sector` | select | Industry sector (dev, design, marketing, data, devops, etc.) |
| `jobType` | select | Employment type (full-time, contract, freelance, etc.) |
| `level` | select | Seniority level (junior, mid, senior, lead, manager) |
| `minSalary` | integer | Minimum salary filter in USD/year |
| `jobIds` | array | Job IDs or slugs to fetch (mode=getJob) |
| `maxItems` | integer | Maximum records to return (1–10,000, default 100) |

#### Example Input — Search Python developer jobs in the UK

```json
{
  "mode": "search",
  "query": "python developer",
  "geo": "uk",
  "sector": "dev",
  "level": "senior",
  "maxItems": 20
}
````

#### Example Input — Browse all remote development jobs

```json
{
  "mode": "search",
  "sector": "dev",
  "maxItems": 50
}
```

#### Example Input — Get specific jobs by ID

```json
{
  "mode": "getJob",
  "jobIds": ["42001-senior-python-developer", "12345-react-engineer"],
  "maxItems": 10
}
```

### Output

Each record in the dataset contains:

| Field | Type | Description |
|---|---|---|
| `jobId` | string | Unique job ID |
| `jobSlug` | string | URL-friendly job slug |
| `title` | string | Job title |
| `companyName` | string | Hiring company name |
| `companyLogo` | string | URL to company logo image |
| `sector` | string | Primary industry sector |
| `sectors` | array | All industry sectors (when multiple) |
| `jobType` | string | Employment type |
| `location` | string | Geographic location requirement |
| `level` | string | Seniority level |
| `excerpt` | string | Short job description excerpt |
| `description` | string | Full plain-text job description |
| `salaryMin` | integer | Minimum salary (USD/year) |
| `salaryMax` | integer | Maximum salary (USD/year) |
| `salaryCurrency` | string | Salary currency code |
| `salaryPeriod` | string | Salary period (year, month, hour) |
| `datePosted` | string | Publication date (ISO 8601) |
| `jobUrl` | string | URL to the full job listing |
| `applyUrl` | string | URL to apply for the job |
| `sourceUrl` | string | Source URL |
| `recordType` | string | Always `"job"` |
| `scrapedAt` | string | UTC timestamp of scrape |

#### Example Output Record

```json
{
  "jobId": "42001",
  "jobSlug": "42001-senior-python-developer",
  "title": "Senior Python Developer",
  "companyName": "CloudTech Ltd",
  "sector": "Development",
  "jobType": "full-time",
  "location": "UK",
  "level": "Senior",
  "excerpt": "We need a skilled Python developer for our backend team.",
  "description": "We are looking for a Senior Python Developer with 5+ years of experience in Django and FastAPI. REST APIs, AWS, PostgreSQL.",
  "salaryMin": 80000,
  "salaryMax": 120000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "datePosted": "2026-05-28T09:00:00+00:00",
  "jobUrl": "https://jobicy.com/jobs/42001-senior-python-developer",
  "applyUrl": "https://jobicy.com/jobs/42001-senior-python-developer",
  "sourceUrl": "https://jobicy.com/jobs/42001-senior-python-developer",
  "recordType": "job",
  "scrapedAt": "2026-05-30T12:00:00+00:00"
}
```

### FAQ

**Q: Do I need an API key or account?**
No. The Jobicy API is completely public and free to use.

**Q: What regions are supported?**
USA, UK, Canada, Australia, Europe, Germany, France, India, Brazil, Spain, Netherlands, Portugal, Poland, Sweden, Switzerland, Italy, Israel, Singapore, New Zealand, and Worldwide.

**Q: How is salary data provided?**
When available, salary is broken into `salaryMin`, `salaryMax`, `salaryCurrency`, and `salaryPeriod`. Jobs without salary data simply omit these fields.

**Q: What IT sectors are available?**
Development, DevOps, Data, Design, Marketing, Sales, Finance, HR, Management, Writing, Legal, Education, Health, Product, Security, QA, and more.

**Q: What seniority levels can I filter?**
Junior, Mid, Senior, Lead, Manager, Director, Executive, and Internship.

**Q: How often is the data updated?**
Jobicy updates their job board continuously with new verified remote positions.

**Q: What is the `minSalary` filter?**
It filters out jobs where the maximum advertised salary is below your threshold. Jobs with no salary data are always included (so you never miss good opportunities due to missing metadata).

# Actor input Schema

## `mode` (type: `string`):

What to fetch: search jobs or look up specific jobs by ID.

## `query` (type: `string`):

Keyword to search in job title and tags (e.g. 'python developer', 'react', 'AWS').

## `geo` (type: `string`):

Filter jobs by geographic region.

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

Additional text filter on location field (e.g. 'London', 'Remote UK'). Applied client-side after API fetch.

## `sector` (type: `string`):

Filter by industry sector.

## `jobType` (type: `string`):

Filter by employment type.

## `level` (type: `string`):

Filter by seniority level.

## `minSalary` (type: `integer`):

Only include jobs where the maximum salary is at least this value (USD per year). Jobs without salary data are always included.

## `jobIds` (type: `array`):

List of Jobicy job IDs or slugs to fetch specifically.

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

Maximum number of job records to return.

## Actor input object example

```json
{
  "mode": "search",
  "query": "python",
  "geo": "",
  "sector": "",
  "jobType": "",
  "level": "",
  "maxItems": 100
}
```

# Actor output Schema

## `jobs` (type: `string`):

Dataset containing all scraped remote IT/tech job records.

# 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 = {
    "mode": "search",
    "query": "python",
    "geo": "",
    "sector": "",
    "jobType": "",
    "level": "",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/job-serve-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 = {
    "mode": "search",
    "query": "python",
    "geo": "",
    "sector": "",
    "jobType": "",
    "level": "",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/job-serve-scraper").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 '{
  "mode": "search",
  "query": "python",
  "geo": "",
  "sector": "",
  "jobType": "",
  "level": "",
  "maxItems": 100
}' |
apify call crawlerbros/job-serve-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/job-serve-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JobServe Scraper (Remote IT Jobs via Jobicy)",
        "description": "Scrape remote IT and tech job listings from Jobicy's public API. Search by keyword, industry sector, geographic region, job level, and salary range. No authentication required.",
        "version": "1.0",
        "x-build-id": "nkdB61NzpjDitRh5Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~job-serve-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-job-serve-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~job-serve-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-job-serve-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~job-serve-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-job-serve-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "getJob"
                        ],
                        "type": "string",
                        "description": "What to fetch: search jobs or look up specific jobs by ID.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search keyword / tag",
                        "type": "string",
                        "description": "Keyword to search in job title and tags (e.g. 'python developer', 'react', 'AWS')."
                    },
                    "geo": {
                        "title": "Geographic region",
                        "enum": [
                            "",
                            "usa",
                            "uk",
                            "canada",
                            "australia",
                            "europe",
                            "worldwide",
                            "germany",
                            "france",
                            "india",
                            "brazil",
                            "spain",
                            "netherlands",
                            "portugal",
                            "poland",
                            "sweden",
                            "switzerland",
                            "italy",
                            "israel",
                            "singapore",
                            "new-zealand"
                        ],
                        "type": "string",
                        "description": "Filter jobs by geographic region.",
                        "default": ""
                    },
                    "location": {
                        "title": "Location (text filter)",
                        "type": "string",
                        "description": "Additional text filter on location field (e.g. 'London', 'Remote UK'). Applied client-side after API fetch."
                    },
                    "sector": {
                        "title": "Industry / Sector",
                        "enum": [
                            "",
                            "dev",
                            "marketing",
                            "hr",
                            "management",
                            "education",
                            "healthcare",
                            "data-science",
                            "technical-support",
                            "business"
                        ],
                        "type": "string",
                        "description": "Filter by industry sector.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "",
                            "full-time",
                            "part-time",
                            "contract",
                            "freelance",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Filter by employment type.",
                        "default": ""
                    },
                    "level": {
                        "title": "Job level",
                        "enum": [
                            "",
                            "junior",
                            "mid",
                            "senior",
                            "lead",
                            "manager",
                            "director",
                            "executive",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Filter by seniority level.",
                        "default": ""
                    },
                    "minSalary": {
                        "title": "Minimum salary (USD/year)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Only include jobs where the maximum salary is at least this value (USD per year). Jobs without salary data are always included."
                    },
                    "jobIds": {
                        "title": "Job IDs / slugs (mode=getJob)",
                        "type": "array",
                        "description": "List of Jobicy job IDs or slugs to fetch specifically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job records to return.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
