Cezanne Recruitment (formerly Occupop) Jobs API.

import re
import requests
from urllib.parse import urlparse

HTML_HEADERS = {
    "Accept": "text/html",
    "Accept-Language": "en-GB,en;q=0.9",
}

# Only these public hosts/paths identify a real vacancy link.
APPLICATION_PATHS = {
    "api.occupop.com": ("/job/application/", "/shared/job/"),
    "recruitment.cezannehr.com": ("/job/application/",),
}
HREF = re.compile(r'href\s*=\s*["\']([^"\']+)["\']', re.I)
SLUG = re.compile(r"[a-z0-9_-]+", re.I)

def parse_application_slugs(page_source: str) -> list[str]:
    slugs, seen = [], set()
    for href in HREF.findall(page_source):
        parsed = urlparse(href)
        prefixes = APPLICATION_PATHS.get(parsed.netloc.lower())
        if not prefixes or not parsed.path.startswith(prefixes):
            continue
        slug = parsed.path.rstrip("/").rsplit("/", 1)[-1]
        if SLUG.fullmatch(slug) and slug not in seen:
            seen.add(slug)
            slugs.append(slug)
    return slugs

careers_url = "https://babington.co.uk/about-us/work-with-us/"
page = requests.get(careers_url, headers=HTML_HEADERS, timeout=30).text
slugs = parse_application_slugs(page)
print(len(slugs), "application links")

from html import unescape

FRAME = re.compile(r"https://api\.occupop\.com/api/jobs-frame/[A-Za-z0-9_-]{30,}")

def extract_frame_url(page_source: str) -> str | None:
    # Company sites escape the URL in HTML or JSON; normalize before matching.
    decoded = unescape(page_source).replace("\\/", "/")
    match = FRAME.search(decoded)
    return match.group(0) if match else None

if not slugs:
    frame_url = extract_frame_url(page)
    if frame_url is None:
        # AEM-backed boards expose the frame URL via the page model JSON.
        model = requests.get(
            careers_url.rstrip("/") + "/.model.json",
            headers={**HTML_HEADERS, "Accept": "application/json"},
            timeout=30,
        )
        frame_url = extract_frame_url(model.text) if model.ok else None
    if frame_url:
        frame_html = requests.get(frame_url, headers=HTML_HEADERS, timeout=30).text
        slugs = parse_application_slugs(frame_html)

GRAPHQL_URL = "https://gateway.server.occupop.com/graphql"
DETAIL_QUERY = (
    "query q($uuid: String!) { careersPage { getJob(uuid: $uuid) { "
    "title uniqueSlug uuid closedForApplicants description period contract "
    "publishedAt closeDate workplace isActive language companyLogo "
    "salary { type period start end details } "
    "jobListingsConfig { uuid settings { id uuid } } "
    "hiringCompany { name uuid } "
    "location { city cityFullName country countryShort state } "
    "subsectors { name translationKey sector { name translationKey } } "
    "} } }"
)
GRAPHQL_HEADERS = {
    "Accept": "application/json",
    "Content-Language": "en",
    "Content-Timezone-name": "UTC",
    "Content-Timezone-offset": "+00:00",
    "Origin": "https://recruitment.cezannehr.com",
    "Referer": "https://recruitment.cezannehr.com/",
}

def fetch_job(slug: str) -> dict | None:
    resp = requests.post(
        GRAPHQL_URL,
        headers=GRAPHQL_HEADERS,
        json={"query": DETAIL_QUERY, "variables": {"uuid": slug}},
        timeout=30,
    )
    resp.raise_for_status()
    payload = resp.json()
    if payload.get("errors"):
        return None  # 200 + errors[] is returned for unknown slugs
    return ((payload.get("data") or {}).get("careersPage") or {}).get("getJob")

def to_record(job: dict) -> dict | None:
    # Filled or hidden roles are still linked; exclude them from the snapshot.
    if job.get("closedForApplicants") or job.get("isActive") is False:
        return None
    location = job.get("location") or {}
    salary = job.get("salary") or {}
    company = job.get("hiringCompany") or {}
    return {
        "external_id": job["uuid"],            # immutable UUID = primary key
        "unique_slug": job.get("uniqueSlug"),  # mutable; metadata only
        "title": job.get("title"),
        "company": company.get("name"),
        "location": location.get("cityFullName") or location.get("city") or location.get("country"),
        "country_code": location.get("countryShort"),
        "contract": job.get("contract"),
        "workplace": job.get("workplace"),
        "salary_min": salary.get("start"),
        "salary_max": salary.get("end"),
        "salary_period": salary.get("period"),
        "posted_at": job.get("publishedAt"),
        "closes_at": job.get("closeDate"),
        "description": job.get("description"),
    }

records = []
for slug in slugs:
    job = fetch_job(slug)
    if job and (record := to_record(job)):
        records.append(record)
print(len(records), "open jobs")