ApplicantPool Jobs API.

from urllib.parse import urlparse

ROOT_DOMAIN = "applicantpool.com"
RESERVED = {"api", "app", "mail", "secure", "support", "www"}

def parse_board(url: str):
    """Return (tenant, surface) for an ApplicantPool board or job URL."""
    parsed = urlparse(url)
    labels = parsed.netloc.lower().rstrip(".").split(".")
    if len(labels) != 3 or ".".join(labels[1:]) != ROOT_DOMAIN:
        return None
    tenant = labels[0]
    if tenant in RESERVED:
        return None

    segments = [s for s in parsed.path.split("/") if s]
    if not segments or segments[0] not in ("jobs", "internaljobs"):
        return None
    return tenant, segments[0]

print(parse_board("https://cameroncountytx.applicantpool.com/jobs/1310915"))
# ('cameroncountytx', 'jobs')

import re
import requests

BOARD_COMPONENT = re.compile(
    r"componentData\s*:\s*[{]\s*organizationId\s*:\s*([0-9]+)\s*,"
    r"\s*domainId\s*:\s*([0-9]+)\s*,"
    r"\s*getParams\s*:\s*([{][^{}]*[}])\s*,"
    r"\s*domainName\s*:\s*\"([^\"]+)\"\s*,"
    r"\s*subdomainName\s*:\s*\"([^\"]+)\""
)

def read_board_proof(session, tenant: str, surface: str) -> dict:
    board_url = f"https://{tenant}.{ROOT_DOMAIN}/{surface}/"
    resp = session.get(board_url, headers={"Accept": "text/html"}, timeout=30)
    resp.raise_for_status()

    # A disabled career site redirects to /notset.php?disabled=1 — not an error.
    if "notset.php" in resp.url and "disabled=1" in resp.url:
        raise LookupError(f"ApplicantPool career site {tenant} is disabled")

    matches = BOARD_COMPONENT.findall(resp.text)
    proofs = {(m[0], m[1]) for m in matches if m[4].lower() == tenant}
    if len(proofs) != 1:
        raise LookupError("board omitted or contradicted its domain proof")

    organization_id, domain_id = proofs.pop()
    return {"organization_id": organization_id, "domain_id": domain_id}

session = requests.Session()
proof = read_board_proof(session, "cameroncountytx", "jobs")
print(proof)  # {'organization_id': '...', 'domain_id': '...'}

import json
from urllib.parse import quote

def fetch_jobs(session, tenant: str, surface: str, domain_id: str) -> list[dict]:
    is_internal = 1 if surface == "internaljobs" else 0
    get_params = quote(json.dumps({"isInternal": is_internal}, separators=(",", ":")))
    url = f"https://{tenant}.{ROOT_DOMAIN}/core/jobs/{domain_id}?getParams={get_params}"

    resp = session.get(url, headers={"Accept": "application/json"}, timeout=30)
    resp.raise_for_status()
    payload = resp.json()

    if not payload.get("success"):
        raise RuntimeError("ApplicantPool listings API reported failure")

    data = payload.get("data") or {}
    jobs = data.get("jobs") or []
    count = data.get("jobCount")
    if count is None or count != len(jobs):
        raise RuntimeError("authoritative jobCount disagreed with the returned rows")
    return jobs

jobs = fetch_jobs(session, "cameroncountytx", "jobs", proof["domain_id"])
print(f"{len(jobs)} open jobs")

def map_listing(job: dict, tenant: str, surface: str, domain_id: str) -> dict | None:
    if str(job.get("siteId")) != str(domain_id):
        return None  # cross-tenant row — reject it
    if (job.get("subdomain") or "").lower() != tenant:
        return None

    job_id = job["id"]
    country = {"USA": "US", "CAN": "CA"}.get(
        (job.get("iso3") or "").upper(), job.get("iso3")
    )
    return {
        "id": job_id,
        "title": (job.get("title") or "").strip(),
        "url": f"https://{tenant}.{ROOT_DOMAIN}/{surface}/{job_id}",
        "department": job.get("orgTitle"),
        "employment_type": job.get("employmentType"),
        "workplace_type": job.get("workplaceType"),
        "classification": job.get("classification"),
        "location": job.get("jobLocation") or job.get("city"),
        "city": job.get("city"),
        "state": job.get("abbreviation"),
        "country": country,
        "starts_at": job.get("startDateRef"),
        "ends_at": job.get("endDateRef"),
    }

rows = [map_listing(j, "cameroncountytx", "jobs", proof["domain_id"]) for j in jobs]
rows = [r for r in rows if r]

DETAIL_COMPONENT = re.compile(
    r"componentData\s*:\s*[{]\s*token\s*:\s*\"[^\"]*\"\s*,"
    r"\s*organizationId\s*:\s*([0-9]+)\s*,"
    r"\s*domainId\s*:\s*([0-9]+)\s*,"
    r"\s*domainTitle\s*:\s*\"((?:[^\"]|\\.)*)\"\s*,"
    r"\s*jobListingId\s*:\s*([0-9]+)"
)

def fetch_detail(session, tenant: str, surface: str, job_id: str) -> dict | None:
    page_url = f"https://{tenant}.{ROOT_DOMAIN}/{surface}/{job_id}"
    page = session.get(page_url, headers={"Accept": "text/html"}, timeout=30)
    if page.status_code in (404, 410):
        return None  # removal candidate
    page.raise_for_status()

    proofs = {m for m in DETAIL_COMPONENT.findall(page.text) if m[3] == str(job_id)}
    if len(proofs) != 1:
        raise RuntimeError("detail page omitted its domain and job proof")
    organization_id, domain_id, company_name, _ = proofs.pop()

    api = f"https://{tenant}.{ROOT_DOMAIN}/core/jobs/{domain_id}/{job_id}/job-details"
    resp = session.get(api, headers={"Accept": "application/json"}, timeout=30)
    if resp.status_code in (404, 410):
        return None
    resp.raise_for_status()

    detail = (resp.json() or {}).get("data") or {}
    return {
        "id": detail.get("id"),
        "title": detail.get("title"),
        "description_html": detail.get("description"),
        "benefits": detail.get("benefits"),
        "pay_details": detail.get("payDetails"),
        "company_name": company_name,
        "organization_id": organization_id,
        "url": page_url,
    }