# Jobsite.co.uk Jobs Scraper (`shahidirfan/jobsite-co-uk-jobs-scraper`) Actor

Extract jobs from Jobsite.co.uk with ease. Scrape job titles, companies, locations, salaries, job descriptions, posting dates, employment types, and application URLs using keywords or search URLs. Ideal for recruitment, job aggregation, market research, and HR analytics.

- **URL**: https://apify.com/shahidirfan/jobsite-co-uk-jobs-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Jobs, Automation, Developer tools
- **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/platform/actors/running/actors-in-store#pay-per-usage

## 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Jobsite.co.uk Jobs Scraper

Extract comprehensive job listings from Jobsite.co.uk with ease. Collect job titles, companies, locations, salaries, posting dates, and descriptions from one of the UK's largest job boards. Perfect for job market research, recruitment intelligence, and automated job monitoring.

### Features

- **Keyword Search** — Search for any job title, skill, or role
- **Location Filtering** — Narrow results to any UK city or region
- **URL-Based Scraping** — Paste any Jobsite.co.uk search URL directly
- **Automatic Pagination** — Collects across multiple pages up to your target count
- **Reliable Large Runs** — Continues past the first 100 listings for broader job market coverage
- **Richer Job Metadata** — Collect company identifiers, listing labels, placement metadata, and job visibility flags
- **Clean Data Output** — Removes null and empty values while preserving valid `false` boolean fields
- **Proxy Support** — Works with Apify Proxy for reliable, uninterrupted collection

---

### Use Cases

#### Job Market Research

Analyse job demand across industries and locations. Track how many positions are open for specific roles and identify where demand is growing.

#### Recruitment Intelligence

Monitor competitor hiring activity and salary benchmarks. Build datasets to identify top employers in your sector and understand compensation trends.

#### Automated Job Alerts

Schedule regular runs to stay updated on new postings for specific roles or companies. Export results to Google Sheets or Airtable for easy tracking.

#### Career Planning

Research the most in-demand skills for your target role across different UK locations. Compare salary ranges and identify the best opportunities.

---

### Input Parameters

| Parameter            | Type    | Required | Default             | Description                                                         |
| -------------------- | ------- | -------- | ------------------- | ------------------------------------------------------------------- |
| `startUrl`           | String  | No       | —                   | Full Jobsite.co.uk search URL. Takes priority over keyword/location |
| `keyword`            | String  | No       | `software engineer` | Job title or keyword to search                                      |
| `location`           | String  | No       | `london`            | UK city or region to filter results                                 |
| `results_wanted`     | Integer | No       | `20`                | Maximum number of job listings to collect                           |
| `max_pages`          | Integer | No       | `10`                | Maximum search result pages to visit (25 jobs per page)             |
| `proxyConfiguration` | Object  | No       | —                   | Apify Proxy settings for reliable access                            |

---

### Output Data

Each item in the dataset contains:

| Field            | Type    | Description                                   |
| ---------------- | ------- | --------------------------------------------- |
| `title`          | String  | Job title                                     |
| `raw_job_id`     | Number  | Native listing ID from the source             |
| `company`        | String  | Hiring company name                           |
| `company_id`     | Number  | Native company identifier                     |
| `location`       | String  | Job location                                  |
| `salary`         | String  | Salary range (when available)                 |
| `date_posted`    | String  | Date posted (YYYY-MM-DD format)               |
| `job_url`        | String  | Direct link to the job listing                |
| `description`    | String  | Job description snippet                       |
| `labels`         | Array   | Listing labels when provided                  |
| `top_labels`     | Array   | Highlight labels such as featured or premium  |
| `work_from_home` | String  | Remote/hybrid work indicator (when available) |
| `source`         | String  | Original job board source                     |
| `search_page`    | Number  | Result page where the listing was collected   |
| `search_url`     | String  | Search URL used to collect the listing        |
| `is_sponsored`   | Boolean | Whether the listing is sponsored              |
| `is_highlighted` | Boolean | Whether the listing is highlighted            |
| `is_top_job`     | Boolean | Whether the listing is marked as a top job    |
| `is_backfilled`  | Boolean | Whether the listing is backfilled             |

---

### Usage Examples

#### Search by Keyword Only

Find all admin jobs across the UK:

```json
{
    "keyword": "admin",
    "results_wanted": 50
}
````

#### Search by Keyword and Location

Find software engineering roles in Manchester:

```json
{
    "keyword": "software engineer",
    "location": "manchester",
    "results_wanted": 100,
    "max_pages": 5
}
```

#### Use a Direct Search URL

Paste any Jobsite.co.uk search URL directly — keyword, location, and filters are preserved:

```json
{
    "startUrl": "https://www.jobsite.co.uk/jobs/nurse/in-london",
    "results_wanted": 200
}
```

#### With Proxy for Reliability

```json
{
    "keyword": "project manager",
    "location": "birmingham",
    "results_wanted": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

***

### Sample Output

```json
{
    "id": "b65d3cf0-28ec-4941-ba2d-5ee1e8b3f873",
    "raw_job_id": 107478229,
    "title": "Software Engineer",
    "company": "Example Employer",
    "company_id": 1365229,
    "location": "London",
    "salary": "£70k - 90k per year",
    "date_posted": "2026-06-05",
    "job_url": "https://www.jobsite.co.uk/job/software-engineer/example-employer-job107484073",
    "description": "Join a growing engineering team building production systems...",
    "labels": ["Easy Apply"],
    "top_labels": ["FEATURED"],
    "search_page": 1,
    "search_url": "https://www.jobsite.co.uk/jobs/software-engineer/in-london",
    "is_sponsored": false,
    "is_highlighted": false,
    "is_top_job": false,
    "is_backfilled": true,
    "source": "Totaljobs.com"
}
```

***

### Tips for Best Results

#### URL Patterns

- Keyword only: `https://www.jobsite.co.uk/jobs/admin`
- Keyword + location: `https://www.jobsite.co.uk/jobs/nurse/in-london`
- All URL formats are supported when using the `startUrl` field

#### Getting More Results

- Each page contains 25 jobs — set `max_pages` to control how many pages are visited
- Set `results_wanted` to your exact target count to avoid over-collection
- For large collections (500+), use residential proxies for stability
- Set `max_pages` high enough for your target count. Each page usually contains 25 listings

#### Start Small

- Test with `results_wanted: 20` first to verify the search produces relevant results
- Use `startUrl` with an existing Jobsite search URL to apply any advanced filters

***

### Integrations

Connect your data with:

- **Google Sheets** — Export for job tracking and analysis
- **Airtable** — Build searchable job databases
- **Slack** — Get notifications when new jobs are found
- **Make / Zapier** — Automate job monitoring workflows
- **Webhooks** — Send data to any custom endpoint

#### Export Formats

- **JSON** — For developers and APIs
- **CSV** — For spreadsheet analysis
- **Excel** — For business reporting
- **XML** — For system integrations

***

### Frequently Asked Questions

#### What URL formats does the scraper support?

Any standard Jobsite.co.uk search URL works, including `/jobs/keyword`, `/jobs/keyword/in-location`, and URLs with page parameters.

#### Can I scrape without a keyword?

Yes — use `startUrl` with any Jobsite.co.uk URL, or omit both keyword and location to use the default search.

#### How many jobs can I collect?

Jobsite.co.uk can have thousands of results per search. Set `results_wanted` to your target and the scraper will paginate automatically.

#### Why are some fields missing from results?

Fields like `salary`, `work_from_home`, `labels`, and `top_labels` are only included when the job listing provides that information. Empty fields are excluded to keep the dataset clean, but valid boolean values such as `false` are preserved.

#### What if I get blocked?

Enable Apify Proxy with residential groups in `proxyConfiguration` for more reliable access.

#### How do I schedule regular runs?

Use Apify's Scheduler to run the actor on a recurring schedule — daily, weekly, or at any interval.

***

### Support

For issues or feature requests, contact support through the Apify Console.

#### Resources

- [Apify Documentation](https://docs.apify.com/)
- [API Reference](https://docs.apify.com/api/v2)
- [Scheduling Runs](https://docs.apify.com/schedules)

***

### Legal Notice

This actor is designed for legitimate data collection purposes. Users are responsible for ensuring compliance with Jobsite.co.uk's terms of service and applicable laws. Use data responsibly and respect rate limits.

# Actor input Schema

## `startUrl` (type: `string`):

A Jobsite.co.uk jobs search URL. If provided, overrides keyword and location. Example: https://www.jobsite.co.uk/jobs/admin or https://www.jobsite.co.uk/jobs/software-engineer/in-london

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

Job search keyword(s), e.g. 'software engineer', 'admin', 'nurse'. Used only if Start URL is not provided.

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

Location filter, e.g. 'london', 'manchester', 'birmingham'. Used only if Start URL is not provided.

## `results_wanted` (type: `integer`):

Maximum number of job listings to collect.

## `max_pages` (type: `integer`):

Safety cap on the number of search result pages to visit (25 jobs per page).

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

Use Apify Proxy for reliable scraping. Residential proxies recommended.

## Actor input object example

```json
{
  "startUrl": "https://www.jobsite.co.uk/jobs/admin",
  "keyword": "software engineer",
  "location": "london",
  "results_wanted": 20,
  "max_pages": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrl": "https://www.jobsite.co.uk/jobs/admin",
    "keyword": "software engineer",
    "location": "london",
    "results_wanted": 20,
    "max_pages": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/jobsite-co-uk-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrl": "https://www.jobsite.co.uk/jobs/admin",
    "keyword": "software engineer",
    "location": "london",
    "results_wanted": 20,
    "max_pages": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/jobsite-co-uk-jobs-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 '{
  "startUrl": "https://www.jobsite.co.uk/jobs/admin",
  "keyword": "software engineer",
  "location": "london",
  "results_wanted": 20,
  "max_pages": 10
}' |
apify call shahidirfan/jobsite-co-uk-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=shahidirfan/jobsite-co-uk-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobsite.co.uk Jobs Scraper",
        "description": "Extract jobs from Jobsite.co.uk with ease. Scrape job titles, companies, locations, salaries, job descriptions, posting dates, employment types, and application URLs using keywords or search URLs. Ideal for recruitment, job aggregation, market research, and HR analytics.",
        "version": "0.0",
        "x-build-id": "Q9odFshKbO59cWEiY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shahidirfan~jobsite-co-uk-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shahidirfan-jobsite-co-uk-jobs-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/shahidirfan~jobsite-co-uk-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-shahidirfan-jobsite-co-uk-jobs-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/shahidirfan~jobsite-co-uk-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-shahidirfan-jobsite-co-uk-jobs-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",
                "properties": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "A Jobsite.co.uk jobs search URL. If provided, overrides keyword and location. Example: https://www.jobsite.co.uk/jobs/admin or https://www.jobsite.co.uk/jobs/software-engineer/in-london"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Job search keyword(s), e.g. 'software engineer', 'admin', 'nurse'. Used only if Start URL is not provided."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location filter, e.g. 'london', 'manchester', 'birmingham'. Used only if Start URL is not provided."
                    },
                    "results_wanted": {
                        "title": "Maximum number of jobs",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of job listings to collect.",
                        "default": 20
                    },
                    "max_pages": {
                        "title": "Maximum pages to visit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Safety cap on the number of search result pages to visit (25 jobs per page).",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy for reliable scraping. Residential proxies recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
