Hireology Jobs API.

import re
import requests

CAREERS_HOST = "https://careers.hireology.com"
API_BASE = "https://api.hireology.com/v2"

# The short-lived JWT sits in the inline startingData blob on the SSR page.
API_TOKEN_RE = re.compile(
    r'"apiToken"\s*:\s*"(eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)"'
)

def bootstrap_token(slug: str) -> str:
    resp = requests.get(f"{CAREERS_HOST}/{slug}", timeout=30)
    resp.raise_for_status()
    match = API_TOKEN_RE.search(resp.text)
    if not match:
        raise RuntimeError(f"Could not extract apiToken for {slug}")
    return match.group(1)

token = bootstrap_token("theindigoroadhospitalitygroup")
print(f"Bootstrapped token: {token[:12]}...")

PAGE_SIZE = 10  # server-fixed: larger pageSize values are ignored

def fetch_page(slug: str, token: str, page: int) -> dict:
    url = f"{API_BASE}/public/careers/{slug}"
    headers = {
        "Authorization": f"Bearer {token}",
        "Accept": "application/json",
    }
    resp = requests.get(
        url,
        params={"page": page, "pageSize": PAGE_SIZE},
        headers=headers,
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()

body = fetch_page("theindigoroadhospitalitygroup", token, 1)
print(f"count={body.get('count')} page_size={body.get('page_size')}")
print(f"jobs on page 1: {len(body.get('data') or [])}")

import time

def scrape_all(slug: str) -> list:
    token = bootstrap_token(slug)
    page, seen, jobs = 1, 0, []
    while True:
        try:
            body = fetch_page(slug, token, page)
        except requests.HTTPError as exc:
            if exc.response is not None and exc.response.status_code == 401:
                token = bootstrap_token(slug)  # JWT expired mid-run
                body = fetch_page(slug, token, page)
            else:
                raise
        batch = body.get("data") or []
        jobs.extend(batch)
        total = body.get("count") or 0
        page_size = body.get("page_size") or PAGE_SIZE
        seen += len(batch)
        # Stop on the reported total, or on a short/empty page when count is absent.
        if (total and seen >= total) or len(batch) < page_size:
            break
        page += 1
        time.sleep(2)  # single worker, ~1 request / 2s
    return jobs

all_jobs = scrape_all("theindigoroadhospitalitygroup")
print(f"Collected {len(all_jobs)} jobs")

def normalize(job: dict, slug: str) -> dict:
    job_id = str(job["id"])

    listing_url = (
        job.get("career_site_url")
        or (CAREERS_HOST + job["career_site_path"] if job.get("career_site_path") else None)
        or f"{CAREERS_HOST}/{slug}/{job_id}/description"
    )
    apply_url = (
        CAREERS_HOST + job["application_path"]
        if job.get("application_path")
        else f"{CAREERS_HOST}/careers/{job_id}/application"
    )
    locations = [
        ", ".join(p for p in (loc.get("address"), loc.get("city"), loc.get("state")) if p)
        for loc in (job.get("locations") or [])
    ]

    return {
        "external_id": job_id,
        "title": (job.get("name") or "").strip(),
        "description": job.get("job_description") or "",
        "listing_url": listing_url,
        "apply_url": apply_url,
        "locations": [loc for loc in locations if loc],
        "company": (job.get("organization") or {}).get("name"),
        "employment_status": job.get("employment_status"),
        "remote": job.get("remote"),
        "posted_at": job.get("created_at"),
    }

records = [normalize(job, "theindigoroadhospitalitygroup") for job in all_jobs]
print(f"Normalized {len(records)} records")