# Gradcracker Jobs Scraper (`dakheera47/gradcracker-jobs-scraper`) Actor

Scrape Gradcracker graduate jobs, schemes and internships at scale. Extract structured job data including employer, salary, location, disciplines, degree requirements, start dates, descriptions and application links, ready for analysis, automation or your own job-search tools.

- **URL**: https://apify.com/dakheera47/gradcracker-jobs-scraper.md
- **Developed by:** [Shaheer Sarfaraz](https://apify.com/dakheera47) (community)
- **Categories:**
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 job scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Gradcracker Jobs Scraper

Scrape **Gradcracker jobs** and extract structured UK graduate job data with the **Gradcracker Jobs Scraper**. Get job titles, employers, salaries, locations, degree requirements, disciplines, deadlines, start dates, full job descriptions, and application links from Gradcracker.com.

Built for graduate job aggregators, job search tools, recruitment research, career platforms, data analysis, and automated job monitoring.

### What can you scrape from Gradcracker?

The Gradcracker Jobs Scraper extracts detailed information from graduate job listings, including:

- Job title
- Employer
- Gradcracker job ID
- Job URL
- Employer profile URL
- Application link
- Degree disciplines
- Salary
- UK location
- Degree requirements
- Start date
- Application deadline
- Full job description

Each Gradcracker job is returned as one structured item in the Apify dataset.

### Why use this Gradcracker scraper?

Use this Actor when you need structured **Gradcracker graduate job data** without manually browsing and copying individual listings.

Common use cases include:

- Building a UK graduate jobs aggregator
- Monitoring new graduate jobs and graduate schemes
- Collecting STEM, engineering, software, technology, and data jobs
- Comparing graduate salaries and locations
- Tracking employers recruiting graduates
- Feeding graduate job data into your own application or database
- Running scheduled Gradcracker job searches
- Analysing graduate recruitment trends
- Creating alerts for new graduate opportunities

The Actor can be run manually in Apify Console, on a schedule, or through the Apify API.

### Gradcracker job data example

The Actor writes one item per job to the default dataset:

```json
{
  "source": "gradcracker",
  "sourceJobId": "82285",
  "title": "Technology Graduate Programme",
  "employer": "Capital One",
  "jobUrl": "https://www.gradcracker.com/hub/766/capital-one/graduate-job/82285/technology-graduate-programme",
  "employerUrl": "https://www.gradcracker.com/hub/766/capital-one",
  "applicationLink": "https://www.gradcracker.com/out/766/82285/example",
  "disciplines": "IT, Computing, Software, Systems, Data, AI.",
  "salary": "£46,500 (Nottingham)/£55,500 (London) plus a £5,000 joining bonus",
  "location": "London (Hybrid)",
  "degreeRequired": "Bachelor's",
  "starting": "September 2027",
  "deadline": "30 September 2026",
  "jobDescription": "Full graduate job description..."
}
```

Fields that are unavailable on a particular Gradcracker listing are omitted.

`jobUrl` contains the canonical Gradcracker job detail page.

`applicationLink` contains the application or outbound URL exposed by the listing.

### How to scrape Gradcracker jobs

#### 1. Choose graduate job categories

Add one or more Gradcracker role/category slugs.

For example:

```json
{
  "searchTerms": [
    "web-development",
    "software-systems"
  ]
}
```

#### 2. Choose UK regions

You can search across any combination of the supported Gradcracker regions:

- London and South East
- North West
- Yorkshire
- East Midlands
- West Midlands
- South West

#### 3. Set the maximum number of jobs

Choose how many unique Gradcracker jobs should be collected for each role.

#### 4. Run the Actor

Results are written directly to the default Apify dataset and can be exported as JSON, CSV, Excel, XML, or other supported formats.

### Gradcracker Jobs Scraper input

Example input:

```json
{
  "searchTerms": ["web-development", "software-systems"],
  "regions": ["london-and-south-east", "north-west"],
  "maxResultsPerTerm": 50,
  "detailConcurrency": 2,
  "requestDelayMs": 1000
}
```

| Field               | Type     | Default                               | Description                                          |
| ------------------- | -------- | ------------------------------------- | ---------------------------------------------------- |
| `searchTerms`       | string\[] | `web-development`, `software-systems` | Gradcracker role or category slugs                   |
| `regions`           | string\[] | All supported regions                 | UK regions to search                                 |
| `maxResultsPerTerm` | integer  | `50`                                  | Maximum unique jobs per role across selected regions |
| `detailConcurrency` | integer  | `2`                                   | Number of job detail pages fetched concurrently      |
| `requestDelayMs`    | integer  | `1000`                                | Minimum delay between HTTP request starts            |

`maxResultsPerTerm` supports values from `1` to `200`.

Advanced concurrency and request-delay controls are available for users who need to tune scraping behaviour.

### Gradcracker graduate job regions

The Actor currently supports these Gradcracker region slugs:

```text
london-and-south-east
north-west
yorkshire
east-midlands
west-midlands
south-west
```

You can combine multiple regions in a single run.

### Scrape Gradcracker with the Apify API

Every Actor can be called programmatically through the Apify API.

This makes the Gradcracker scraper suitable for:

- Job search applications
- ETL and data pipelines
- Scheduled graduate job monitoring
- Recruitment intelligence tools
- AI agents and workflows
- Internal databases
- Job notification systems

Run the Actor with your desired search terms and regions, then retrieve the resulting jobs from the default dataset.

### Export Gradcracker job data

After a run finishes, the collected graduate jobs are available in the Apify dataset.

You can use the results directly in Apify or export them for processing in your own systems.

Typical downstream workflows include:

```text
Gradcracker
    ↓
Gradcracker Jobs Scraper
    ↓
Structured Apify dataset
    ↓
Database / job aggregator / analytics / alerts / AI workflow
```

### Reliability and request pacing

The scraper includes configurable request pacing and conservative concurrency limits.

Defaults:

- Detail concurrency: `2`
- Request delay: `1000 ms`
- Maximum concurrency: `4`
- Maximum results per role: `200`

Clearance state exists only for the current Actor run.

Concurrent Cloudflare challenges share a single browser clearance attempt where possible.

A legitimate Gradcracker search with no matching jobs returns a successful empty dataset.

### Gradcracker Jobs Scraper output

The Actor exposes two outputs:

#### Graduate jobs

Structured Gradcracker job listings stored in the default dataset.

Each result can include:

```text
title
employer
jobUrl
employerUrl
applicationLink
disciplines
salary
location
degreeRequired
starting
deadline
jobDescription
```

#### Run summary

A summary of the scrape run is stored in the default key-value store under `OUTPUT`.

It includes information such as:

- Result count
- Search terms
- Regions
- Failed pages

### Frequently asked questions

#### Can I scrape Gradcracker jobs?

This Actor extracts publicly accessible Gradcracker job listings into structured data. You are responsible for ensuring that your use of the data complies with Gradcracker's terms and applicable laws.

#### Does the scraper return full Gradcracker job descriptions?

Yes. When available, `jobDescription` contains the job description extracted from the Gradcracker detail page.

#### Can I get Gradcracker application links?

Yes. When a listing exposes an outbound application URL, it is returned in `applicationLink`.

#### Can I scrape Gradcracker jobs by region?

Yes. You can select one or multiple supported UK regions in the Actor input.

#### Can I scrape specific types of graduate jobs?

Yes. Use Gradcracker role/category slugs in `searchTerms`, such as `web-development` or `software-systems`.

#### Can I schedule Gradcracker scraping?

Yes. You can use Apify schedules to run the Actor automatically and periodically collect fresh graduate job listings.

#### Can I use the Gradcracker scraper through an API?

Yes. The Actor can be started through the Apify API and its dataset results can also be retrieved programmatically.

#### Does the Actor handle Cloudflare?

It includes an automatic Camoufox browser fallback for supported Cloudflare browser challenges. Normal requests remain HTTP-based to reduce unnecessary browser overhead.

### Data use

Before using Gradcracker data commercially or redistributing extracted content, confirm that your intended use complies with the website's terms and applicable law.

Where appropriate, prefer storing structured job metadata and source links rather than republishing third-party content.

# Actor input Schema

## `searchTerms` (type: `array`):

Gradcracker role/category slugs. For example: web-development or software-systems.

## `regions` (type: `array`):

Limit the search to selected Gradcracker regions.

## `maxResultsPerTerm` (type: `integer`):

Maximum number of unique jobs returned for each role across the selected regions.

## `detailConcurrency` (type: `integer`):

Number of job detail pages fetched concurrently.

## `requestDelayMs` (type: `integer`):

Minimum delay between HTTP request starts. Increase this if Gradcracker rate-limits the Actor.

## Actor input object example

```json
{
  "searchTerms": [
    "web-development",
    "software-systems"
  ],
  "regions": [
    "london-and-south-east",
    "north-west",
    "yorkshire",
    "east-midlands",
    "west-midlands",
    "south-west"
  ],
  "maxResultsPerTerm": 50,
  "detailConcurrency": 2,
  "requestDelayMs": 1000
}
```

# Actor output Schema

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

List of graduate jobs extracted from Gradcracker. Each item contains title, employer, URLs, disciplines, salary, location, degree requirement, start date and full jobDescription.

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

Summary of the scrape run including result count, search terms, regions and failed pages stored in the default key-value store under OUTPUT.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("dakheera47/gradcracker-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("dakheera47/gradcracker-jobs-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 '{}' |
apify call dakheera47/gradcracker-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dakheera47/gradcracker-jobs-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/yTZ1FYFNJ2wXepyIf/builds/BAweWfs401JWvj7Xy/openapi.json