# Jobsite Scraper - UK Job Listings Data (`benthepythondev/jobsite-scraper`) Actor

Scrape Jobsite.co.uk jobs: title, company, location, salary, posted date, company URL and direct listing URL.

- **URL**: https://apify.com/benthepythondev/jobsite-scraper.md
- **Developed by:** [ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 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 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

## Jobsite Scraper - UK Job Listings Data

Scrape job listings from **Jobsite.co.uk** in one run. Get job titles, hiring companies, locations, salary text, posted dates, company profile URLs, company logos and direct job URLs from public Jobsite search pages. Export the results to JSON, CSV or Excel, schedule recurring runs, call the actor through the Apify API, or connect the dataset to Google Sheets, Airtable, Clay, HubSpot, Make, Zapier or n8n.

### What is the Jobsite Scraper?

Jobsite is a long-running UK job board in the StepStone/Totaljobs family. It lists roles across technology, finance, sales, operations, healthcare, logistics, engineering, administration, customer support and professional services. Recruiters, sales teams and market researchers use Jobsite data to understand which companies are hiring, which locations are active and how salary language changes across roles.

This actor turns public Jobsite search-result pages into structured data. Jobsite embeds a structured `window.__PRELOADED_STATE__` result-list object in the page, so the actor can read clean job records directly from the server-rendered HTML. It does not require a browser, login, API key or paid unblocker. Because some StepStone-family job boards can timeout on cloud datacenter IP ranges, the actor includes an Apify Residential GB fallback for reliable scheduled runs.

#### What data does it extract?

- **Job title** - role name from the Jobsite listing.
- **Company** - hiring company name.
- **Location** - listed city, area or postcode region.
- **Salary** - salary text when shown by Jobsite.
- **Posted date** - timestamp or posting age from the embedded result state.
- **Work-from-home flag** - remote marker when exposed.
- **Company logo** - logo URL when available.
- **Company URL** - Jobsite company/profile search URL when available.
- **Direct job URL** - decoded stable listing URL, not only a tracking redirect.
- **Search URL** - the source search page that produced the record.
- **Stable ID** - numeric Jobsite job ID.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `searchUrls` | array | Jobsite search-result URLs to scrape. |
| `keyword` | string | Optional keyword used to build a Jobsite search URL. |
| `location` | string | Optional location used with keyword search. |
| `domain` | string | Jobsite domain, usually `www.jobsite.co.uk`. |
| `useResidentialProxy` | boolean | Use Apify Residential proxy as a fallback for reliable Apify runs. |
| `proxyCountry` | string | Residential proxy country, normally `GB`. |
| `maxResults` | integer | Maximum jobs to return per search. |

#### Example input

```json
{
  "searchUrls": ["https://www.jobsite.co.uk/jobs/python/in-london"],
  "maxResults": 50
}
````

Keyword and location search:

```json
{
  "keyword": "data analyst",
  "location": "Manchester",
  "maxResults": 25
}
```

### Output

Each dataset item is one Jobsite listing.

```json
{
  "job_id": "107625859",
  "title": "Software Engineer Python SQL - Market Data",
  "company": "Client Server",
  "location": "Shoreditch, East London (E1), EC2A",
  "url": "https://www.jobsite.co.uk/job/software-engineer-python-sql-market-data/client-server-job107625859",
  "posted": "2026-07-02T09:44:09.57Z",
  "work_from_home": false,
  "salary": "£125000 - £150000 per annum + bonus + benefits",
  "company_logo": "https://www.totaljobs.com/CompanyLogos/example.png",
  "company_url": "https://www.jobsite.co.uk/jobs/client-server?cmpId=1375834&cmp=1",
  "search": "https://www.jobsite.co.uk/jobs/python/in-london"
}
```

### Use cases

- **UK recruiting** - monitor companies hiring across technology, finance, operations, sales, healthcare and support.
- **Sales intelligence** - active hiring can signal budget, expansion, new projects or operational pressure.
- **Market research** - track demand by keyword, location, company and salary text.
- **Job aggregation** - add Jobsite records to a broader UK jobs dataset.
- **Competitor monitoring** - watch hiring patterns for competitors, partners or target accounts.
- **CRM enrichment** - use company URLs and job IDs as inputs for downstream account enrichment.
- **Automation** - send new jobs to Sheets, Airtable, Slack, HubSpot, Clay, Make, Zapier or n8n.

### How to use the data

Use `job_id` or `url` as the deduplication key. For daily monitoring, schedule the actor with a small `maxResults` value and compare new IDs against previous runs. For market research, group rows by keyword, location, company, salary text or posting date. For sales workflows, enrich companies that repeatedly hire for roles related to your product or service.

Jobsite supports many filters on its website. Apply filters such as location, salary, date posted, contract type or remote work on Jobsite, then paste the resulting search URL into `searchUrls`. That gives you the same targeting as the website while returning clean structured records.

Pair this actor with Totaljobs, Reed, NHS Jobs, No Fluff Jobs, StepStone, Bayt, Naukri, Ashby, Recruitee and Workable to cover both public job boards and company career pages. Jobsite is especially useful when you want broad UK coverage but also want direct company profile URLs for lead-generation and account research.

For lead-generation workflows, treat a fresh Jobsite posting as a buying-intent signal. Companies hiring software engineers, analysts, nurses, sales teams, warehouse staff, operations roles or support teams often need related services: recruiting support, HR tools, payroll, training, relocation, managed IT, cloud infrastructure, compliance software or local suppliers. The dataset is intentionally flat so it can be enriched downstream with domains, emails, company size, funding data or CRM account records.

### FAQ

**Does this require a Jobsite account?** No. It reads public search pages.

**Does it use a browser?** No. It uses direct HTTP requests and parses the embedded result-list data.

**Can I scrape filtered Jobsite URLs?** Yes. Paste filtered search URLs into `searchUrls`.

**Can I search by keyword and location?** Yes. Use `keyword` and `location`.

**Does it include salary?** Yes, when Jobsite exposes salary text in the result data.

**Does it include full job descriptions?** This version focuses on search-result data for speed and reliability. Detail-page enrichment can be added later if needed.

**Why does it include a residential proxy option?** Some StepStone-family job boards intermittently timeout on cloud datacenter IPs. The default GB residential fallback improves reliability for scheduled Apify runs.

**Is this useful for lead generation?** Yes. Hiring activity is a strong signal for recruiting, HR tech, training, payroll, sales tools, B2B SaaS and local services.

**How often should I run it?** Daily is practical for monitoring new roles. Weekly is enough for broad market research.

**How do I avoid duplicates?** Use `job_id` or `url` as the stable key.

**Is it legal to scrape Jobsite?** The actor collects publicly available job listing data. You are responsible for using the output lawfully and respecting privacy, employment, anti-spam and platform rules.

### You might also like

- [Totaljobs Scraper](https://apify.com/benthepythondev/totaljobs-scraper)
- [Caterer Jobs Scraper](https://apify.com/benthepythondev/caterer-jobs-scraper)
- [Reed Jobs Scraper](https://apify.com/benthepythondev/reed-jobs-scraper)
- [NHS Jobs Scraper](https://apify.com/benthepythondev/nhs-jobs-scraper)
- [StepStone Scraper](https://apify.com/benthepythondev/stepstone-scraper)
- [Ashby Jobs Scraper](https://apify.com/benthepythondev/ashby-jobs-scraper)

**Keywords:** Jobsite scraper, Jobsite jobs scraper, Jobsite.co.uk scraper, UK jobs scraper, scrape Jobsite, London jobs scraper, UK hiring data, job postings scraper, recruiting leads, hiring intelligence, company hiring data, salary jobs data, Apify jobs scraper.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste Jobsite.co.uk search-results URLs. Filter on the site, then copy the URL. Leave empty to use keyword + location below.

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

Job title or keyword to search (used if no search URLs given), e.g. 'python'.

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

Optional city/region to combine with the keyword, e.g. 'London'.

## `domain` (type: `string`):

Jobsite domain for keyword searches.

## `useResidentialProxy` (type: `boolean`):

Use Apify Residential proxy as a fallback when Jobsite times out on datacenter IPs. Recommended for reliable Apify runs.

## `proxyCountry` (type: `string`):

Residential proxy country for fallback requests. Use GB for jobsite.co.uk.

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

Maximum number of jobs to return per search URL/keyword.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.jobsite.co.uk/jobs/python/in-london"
  ],
  "domain": "www.jobsite.co.uk",
  "useResidentialProxy": true,
  "proxyCountry": "GB",
  "maxResults": 25
}
```

# 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 = {
    "searchUrls": [
        "https://www.jobsite.co.uk/jobs/python/in-london"
    ],
    "domain": "www.jobsite.co.uk",
    "useResidentialProxy": true,
    "proxyCountry": "GB",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/jobsite-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 = {
    "searchUrls": ["https://www.jobsite.co.uk/jobs/python/in-london"],
    "domain": "www.jobsite.co.uk",
    "useResidentialProxy": True,
    "proxyCountry": "GB",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/jobsite-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 '{
  "searchUrls": [
    "https://www.jobsite.co.uk/jobs/python/in-london"
  ],
  "domain": "www.jobsite.co.uk",
  "useResidentialProxy": true,
  "proxyCountry": "GB",
  "maxResults": 25
}' |
apify call benthepythondev/jobsite-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobsite Scraper - UK Job Listings Data",
        "description": "Scrape Jobsite.co.uk jobs: title, company, location, salary, posted date, company URL and direct listing URL.",
        "version": "1.0",
        "x-build-id": "nmocui37fT9VkW5iE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~jobsite-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-jobsite-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/benthepythondev~jobsite-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-jobsite-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/benthepythondev~jobsite-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-jobsite-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": {
                    "searchUrls": {
                        "title": "Jobsite search URLs",
                        "type": "array",
                        "description": "Paste Jobsite.co.uk search-results URLs. Filter on the site, then copy the URL. Leave empty to use keyword + location below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword / job title",
                        "type": "string",
                        "description": "Job title or keyword to search (used if no search URLs given), e.g. 'python'."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional city/region to combine with the keyword, e.g. 'London'."
                    },
                    "domain": {
                        "title": "Domain",
                        "type": "string",
                        "description": "Jobsite domain for keyword searches.",
                        "default": "www.jobsite.co.uk"
                    },
                    "useResidentialProxy": {
                        "title": "Use residential proxy",
                        "type": "boolean",
                        "description": "Use Apify Residential proxy as a fallback when Jobsite times out on datacenter IPs. Recommended for reliable Apify runs.",
                        "default": true
                    },
                    "proxyCountry": {
                        "title": "Proxy country",
                        "type": "string",
                        "description": "Residential proxy country for fallback requests. Use GB for jobsite.co.uk.",
                        "default": "GB"
                    },
                    "maxResults": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of jobs to return per search URL/keyword.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
