ExactHire Jobs API.

import re
from urllib.parse import urlparse

SUFFIX = ".exacthire.com"
RESERVED = {"api", "app", "help", "status", "support", "www"}
TENANT = re.compile("^[a-z0-9](?:[a-z0-9-]{0,98}[a-z0-9])?$", re.IGNORECASE)

def parse_exacthire(url: str) -> dict | None:
    parsed = urlparse(url)
    host = parsed.netloc.lower()
    if parsed.query or parsed.fragment or not host.endswith(SUFFIX):
        return None

    tenant = host[: -len(SUFFIX)]
    if tenant in RESERVED or not TENANT.match(tenant):
        return None

    segments = [s for s in parsed.path.split("/") if s]
    if not segments:
        return {"tenant": tenant, "job_id": None}
    if len(segments) == 2 and segments[0] == "job" and segments[1].isdigit():
        return {"tenant": tenant, "job_id": segments[1]}
    return None

print(parse_exacthire("https://bollingershipyards.exacthire.com/job/201817"))

import requests

API = "https://api.exacthire.com"

def read_envelope(payload: dict) -> dict:
    """Unwrap the ExactHire response envelope, mapping code 406 to a rate limit."""
    code = payload.get("code")
    message = payload.get("message") or ""
    if code == 406 and "blocked" in message.lower():
        raise RuntimeError("ExactHire edge blocked the request — back off and retry")
    content = payload.get("content")
    if not isinstance(content, dict):
        raise RuntimeError("ExactHire response omitted its content object")
    return content

def resolve_site(session, tenant: str) -> dict:
    resp = session.get(f"{API}/api/public/career_sites/{tenant}",
                       headers={"Accept": "application/json"}, timeout=30)
    resp.raise_for_status()
    content = read_envelope(resp.json())

    site = content.get("career_site") or {}
    if content.get("protocol") != "https" or content.get("url") != "exacthire.com":
        raise RuntimeError("career site did not echo the ExactHire vendor host")
    if site.get("archived_at") or site.get("deleted_at"):
        raise LookupError(f"ExactHire career site {tenant} is retired")

    return {
        "tenant": tenant,
        "career_site_id": str(site.get("id")),
        "organization_id": str((content.get("organization") or {}).get("id")),
    }

session = requests.Session()
site = resolve_site(session, "bollingershipyards")
print(site)

def unwrap(wrapper: dict) -> dict | None:
    """ExactHire nests each position under a literal '0' key."""
    position = wrapper.get("0") if isinstance(wrapper, dict) else None
    return position if isinstance(position, dict) else None

def fetch_positions(session, site: dict) -> list[dict]:
    url = f"{API}/api/public/career_sites/{site['career_site_id']}/positions?include_all=0"
    resp = session.get(url, headers={"Accept": "application/json"}, timeout=30)
    resp.raise_for_status()
    content = read_envelope(resp.json())

    rows = []
    for wrapper in content.get("positions") or []:
        position = unwrap(wrapper)
        if not position:
            continue
        # Skip archived, deleted and template records — they are not open jobs.
        if position.get("archived_at") or position.get("deleted_at"):
            continue
        if position.get("is_template") is True:
            continue

        position_id = str(position.get("id") or "")
        title = (position.get("title") or "").strip()
        if not position_id.isdigit() or not title:
            continue

        rows.append({
            "id": position_id,
            "title": title,
            "url": f"https://{site['tenant']}.exacthire.com/job/{position_id}",
            "location": position.get("location"),
            "employment_type": position.get("employment_type"),
            "created_at": position.get("created_at"),
            "updated_at": position.get("updated_at"),
        })
    return rows

positions = fetch_positions(session, site)
print(f"{len(positions)} open positions")

import time

def fetch_detail(session, site: dict, position_id: str) -> dict | None:
    url = (f"{API}/api/public/career_sites/{site['career_site_id']}"
           f"/positions/{position_id}?include_all=0")
    resp = session.get(url, headers={"Accept": "application/json"}, timeout=30)
    if resp.status_code in (404, 410):
        return None
    resp.raise_for_status()

    content = read_envelope(resp.json())
    position = unwrap(content.get("position") or {})
    if not position:
        return None

    template = position.get("application_template") or {}
    return {
        "id": str(position.get("id")),
        "title": (position.get("title") or "").strip(),
        "description_html": position.get("description"),
        "location": position.get("location"),
        "employment_type": position.get("employment_type"),
        "created_at": position.get("created_at"),
        "updated_at": position.get("updated_at"),
        "application_template_id": template.get("id"),
        "organization_id": site["organization_id"],
        "url": f"https://{site['tenant']}.exacthire.com/job/{position['id']}",
    }

for row in positions[:3]:
    print(fetch_detail(session, site, row["id"]))
    time.sleep(0.3)

def classify(session, site: dict, position_id: str) -> str:
    url = (f"{API}/api/public/career_sites/{site['career_site_id']}"
           f"/positions/{position_id}?include_all=0")
    resp = session.get(url, headers={"Accept": "application/json"}, timeout=30)
    if resp.status_code in (404, 410):
        return "removed"
    if not resp.ok:
        return "inconclusive"

    try:
        content = read_envelope(resp.json())
    except RuntimeError:
        return "inconclusive"

    position = unwrap(content.get("position") or {})
    if position is None:
        return "inconclusive"
    if position.get("archived_at") or position.get("deleted_at"):
        return "removed"
    # The exact tombstone: a record whose title is the empty string.
    if position.get("title") == "":
        return "removed"
    return "active" if (position.get("title") or "").strip() else "inconclusive"