# JobServe Scraper - UK IT Contract Jobs and Recruiters (`studio-amba/jobserve-scraper`) Actor

Scrape UK jobs from JobServe, the UK's IT contract board. Each job comes with the advertiser, whether it is an agency or a direct employer, the recruiter contact, day rate, duration and posting date.

- **URL**: https://apify.com/studio-amba/jobserve-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## JobServe Scraper

**JobServe Scraper** extracts job adverts from [JobServe](https://www.jobserve.com/gb/en/Job-Search/), the long-running UK job board for IT contract work. Every job comes with the advertiser, JobServe's own label for the advertiser ("Employment Business", "Employment Agency" or "Company"), the named contact, phone and email where the advert shows them, the day rate or salary, contract duration, start date, posting date and the full advert text.

By default it returns IT & Telecommunications jobs posted in the last 7 days. You can narrow it down by keywords, location, job type and advertiser type, or switch to another JobServe industry.

### How to scrape JobServe data

1. Open JobServe Scraper in the Apify Console.
2. Enter keywords such as `java`, `devops` or `"data engineer"`, or leave the field empty for every job in the industry.
3. Optionally enter a UK location. JobServe searches within 50 miles of it.
4. Keep **Industry** on IT & Telecommunications or pick another one.
5. Pick **Posted within** (today up to 7 days) and the **Job type**.
6. Optionally keep only agencies or only direct employers.
7. Set **Max results** and click **Start**, then download the results from the Output tab or the Apify API.

### What you can use it for

- **Recruiter and agency lists.** Which agencies advertise which IT contracts, with the named recruiter and their phone or email.
- **Contract rate benchmarking.** Day rates by skill, location and IR35 status.
- **Hiring signals.** Direct employers advertising IT roles themselves.
- **Market research** on contract demand: SC/DV-cleared roles, public sector, cloud, data, security.
- **Job aggregation** for IT contractor tools and alerts.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Keywords. Empty = every job in the chosen industry. |
| `location` | string | UK town or city (50-mile radius). Empty = whole UK. |
| `industry` | string | JobServe industry. Default `it` (IT & Telecommunications). |
| `postedWithin` | string | `0` (today) to `7` days. Default `7`. |
| `jobType` | string | `any` (default), `permanent`, `contract`, `contract-permanent`, `temporary`. |
| `advertiserType` | string | `all` (default), `agency` or `direct`. Applied after each advert is read. |
| `maxResults` | integer | Maximum jobs to return. Default 100, hard cap 20,000. |
| `maxConcurrency` | integer | Parallel advert requests. Default 4, hard cap 10. |
| `proxyConfiguration` | object | Default: Apify automatic proxy. |

#### Example input

```json
{
    "searchQuery": "",
    "industry": "it",
    "postedWithin": "7",
    "jobType": "contract",
    "advertiserType": "agency",
    "maxResults": 500
}
```

The advertiser filter is applied after the full advert is read, because JobServe only shows the advertiser label on the advert. A run with `advertiserType: direct` therefore reads more adverts than it returns. About 1 in 10 IT adverts on JobServe comes from a direct employer.

### Output

Each item is one job advert.

| Field | Description |
|-------|-------------|
| `jobId` | JobServe job id |
| `jobTitle` | Job title |
| `advertiser` | Company that placed the advert |
| `advertiserType` | `agency` (label "Employment Business" or "Employment Agency"), `direct_employer` (label "Company") or `null` |
| `advertiserLabel` | JobServe's own label |
| `advertiserListingUrl` | The advertiser's JobServe directory page |
| `contactName`, `contactPhone`, `contactEmail` | Contact details on the advert, when shown |
| `jobType` | Contract, Permanent, Contract/Permanent or Temporary |
| `location`, `industry` | As advertised |
| `duration`, `startDate` | Contract duration and start date, when given |
| `rate`, `rateMin`, `rateMax`, `ratePeriod`, `currency` | Rate or salary text, the numbers parsed from it, `day`/`hour`/`year`, and `GBP` |
| `reference` | Advertiser's job reference |
| `postedDate` | Date and time posted, UK local time |
| `description` | Full advert text |
| `url` | JobServe permalink |
| `scrapedAt` | Run timestamp |

#### Example output

```json
{
    "jobId": "0E072BF8A679C74249",
    "jobTitle": "Call Handler-Helpdesk Engineer- -SC/DV Cleared-London -£300",
    "advertiser": "SmartSourcing Ltd",
    "advertiserType": "agency",
    "advertiserLabel": "Employment Business",
    "advertiserListingUrl": "https://www.jobserve.com/gb/en/Listings/Recruiters/SmartSourcing-Ltd/?lid=7E472EDB49",
    "contactName": "Amie Chesworth",
    "contactPhone": "01782 970834",
    "contactEmail": null,
    "jobType": "Contract",
    "location": "London, UK",
    "industry": "IT",
    "duration": "6 months initially",
    "startDate": "ASAP",
    "rate": "£300/Day",
    "rateMin": 300,
    "rateMax": 300,
    "ratePeriod": "day",
    "currency": "GBP",
    "reference": "JSSS/CH-SWITCH932",
    "postedDate": "2026-10-09T14:09:33",
    "url": "https://www.jobserve.com/hDhPr",
    "scrapedAt": "2026-10-15T08:46:16.192Z"
}
```

### Cost estimate

Each job is one request for the full advert, plus one request per 100 jobs for the result list. A 20-job test run used about $0.0005 of platform usage on Apify's automatic proxy. A week of UK IT adverts (about 3,700 jobs) is about 3,750 requests. Usage for a run only settles after the run has finished with SUCCEEDED, so a dataset read during a run shows a cost that is far too low.

### Limitations

- Contact phone and email are only filled when the advertiser put them on the advert (about half of IT adverts).
- `postedDate` is UK local time without a timezone offset.
- `rateMin` and `rateMax` are parsed from free text. Check `rate` for the exact wording.
- The run fails on purpose when no job is found, so an empty dataset never looks like a successful run.

### About JobServe

JobServe has listed UK jobs since 1993 and is best known for IT contract roles placed by recruitment agencies ("employment businesses"). Adverts carry the agency name, the recruiter's contact details, the rate, duration and start date, which makes it a direct view of the UK IT contract market.

### Maintained by Studio Amba

We run 700+ scrapers for European websites, and the priority is keeping
every one of them working. Automated runs test this actor against the live
site and verify the output is complete. When the website changes, the
scraper usually gets repaired the same day, without you having to report
anything. Questions and issues go straight to the people who built it, and
most get an answer the same day.

If this actor works for you, a review on its Store page helps other people
find it.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API, maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.

# Actor input Schema

## `searchQuery` (type: `string`):

Keywords, for example 'java', 'devops' or '"data engineer"'. Leave empty for every job in the chosen industry.

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

UK town or city, for example 'London'. JobServe searches within 50 miles. Leave empty for the whole UK.

## `industry` (type: `string`):

JobServe industry. Defaults to IT & Telecommunications.

## `postedWithin` (type: `string`):

Only jobs posted today or in the last 1 to 7 days.

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

Permanent, contract, contract or permanent, or temporary.

## `advertiserType` (type: `string`):

Keep only recruitment agencies or only direct employers. JobServe labels every advert as 'Employment Business', 'Employment Agency' or 'Company'. The filter is applied after each advert is read, so a narrow filter reads more adverts than it returns.

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

Maximum number of jobs to return. Each job is one extra request for the full advert. Hard cap 20,000.

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

Parallel advert requests. Hard cap 10.

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

Proxy settings. JobServe has no bot wall; Apify's automatic proxy pool works (recon 2026-10-15). The whole run uses one proxy session because the search lives in the JobServe session.

## Actor input object example

```json
{
  "searchQuery": "developer",
  "industry": "it",
  "postedWithin": "7",
  "jobType": "any",
  "advertiserType": "all",
  "maxResults": 20,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQuery": "developer",
    "industry": "it",
    "postedWithin": "7",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/jobserve-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 = {
    "searchQuery": "developer",
    "industry": "it",
    "postedWithin": "7",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/jobserve-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 '{
  "searchQuery": "developer",
  "industry": "it",
  "postedWithin": "7",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/jobserve-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/jobserve-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/UzRtuZNUcbu3ZugY4/builds/zR0zacnoWM3ejhHlq/openapi.json