PowerSchool Applicant Tracking Enterprise Jobs API.

import re
from urllib.parse import urlparse, parse_qs

SUFFIX = ".atenterprise.powerschool.com"
POD = re.compile(r"^ats[1-9][0-9]?$", re.IGNORECASE)

def parse_url(url: str) -> dict | None:
    parsed = urlparse(url)
    host = parsed.netloc.lower()
    if not host.endswith(SUFFIX):
        return None
    pod = host[: -len(SUFFIX)]
    if not POD.match(pod):
        return None

    parts = parsed.path.strip("/").split("/")
    if len(parts) != 2 or parts[0] != "ats":
        return None
    query = {k: v[0] for k, v in parse_qs(parsed.query).items()}
    company = query.get("COMPANY_ID")
    if not company:
        return None

    # A syndicated apply URL can name a statewide aggregator in COMPANY_ID while
    # the employing district sits in REPRESENTATIVE_COMPANY_ID. The latter wins.
    company = query.get("REPRESENTATIVE_COMPANY_ID") or company
    return {
        "pod": pod.lower(),
        "company_id": company.lower(),
        "job_id": query.get("JOB_ID") if parts[1] == "job_board_form" else None,
    }

def board_url(pod: str, company_id: str, start_index: int = 0) -> str:
    base = f"https://{pod}{SUFFIX}/ats/job_board?COMPANY_ID={company_id}"
    return base if start_index <= 0 else f"{base}&start_index={start_index}"

print(parse_url(
    "https://ats5.atenterprise.powerschool.com/ats/job_board_form"
    "?op=view&JOB_ID=8600046793&COMPANY_ID=JA002638&REPRESENTATIVE_COMPANY_ID=JA003062"
))

import requests
from bs4 import BeautifulSoup

def fetch_board(session: requests.Session, pod: str, company_id: str, start_index: int = 0):
    response = session.get(
        board_url(pod, company_id, start_index),
        headers={"Accept": "text/html,application/xhtml+xml"},
        timeout=30,
    )
    response.raise_for_status()
    # Unknown company: 200 with a tiny script that bounces to the error page.
    if "/ats/error.jsp" in response.text:
        raise RuntimeError(f"PowerSchool has no board for {company_id} on {pod}")
    return BeautifulSoup(response.text, "html.parser")

session = requests.Session()
soup = fetch_board(session, "ats3", "oa002067")

def normalize(value: str) -> str:
    return " ".join((value or "").split())

def header_columns(soup) -> dict:
    columns: dict[str, list[int]] = {}
    for index, cell in enumerate(soup.select("div.rs table thead th")):
        label = normalize(cell.get_text())
        if label:
            columns.setdefault(label, []).append(index)
    return columns

LOCATION_HEADERS = ("System/School", "School or Worksite", "District/Location", "Location")

def cell(cells, columns: dict, header: str) -> str | None:
    for index in columns.get(header, []):
        if index < len(cells):
            text = normalize(cells[index].get_text())
            if text:
                return text
    return None

def parse_rows(soup, pod: str, company_id: str) -> list[dict]:
    columns = header_columns(soup)
    listings = []
    for row in soup.select("div.rs table tbody tr"):
        anchor = row.select_one("a[href*='job_board_form']")
        cells = row.find_all("td")
        if not anchor or not cells:
            continue
        job_id = (parse_qs(urlparse(anchor["href"]).query).get("JOB_ID") or [""])[0]
        title = cell(cells, columns, "Job Title") or normalize(anchor.get_text())
        if not job_id or not title:
            continue
        listings.append({
            "id": job_id,
            "title": title,
            "location": next(
                (v for v in (cell(cells, columns, h) for h in LOCATION_HEADERS) if v), None
            ),
            "posted_at": cell(cells, columns, "Posting Date"),
            "closes_at": cell(cells, columns, "Closing Date"),
            "listing_url": (
                f"https://{pod}{SUFFIX}/ats/job_board_form"
                f"?op=view&JOB_ID={job_id}&COMPANY_ID={company_id}"
            ),
        })
    return listings

listings = parse_rows(soup, "ats3", "oa002067")
print(f"{len(listings)} vacancies on this page")

def next_start_index(soup, current: int) -> int | None:
    offsets = set()
    for anchor in soup.select("a[href*='start_index=']"):
        values = parse_qs(urlparse(anchor["href"]).query).get("start_index") or []
        if len(values) == 1 and values[0].isdigit():
            offsets.add(int(values[0]))
    forward = sorted(o for o in offsets if o > current)
    return forward[0] if forward else None

def crawl(session: requests.Session, pod: str, company_id: str) -> list[dict]:
    listings, start, seen = [], 0, set()
    while True:
        soup = fetch_board(session, pod, company_id, start)
        for row in parse_rows(soup, pod, company_id):
            if row["id"] not in seen:
                seen.add(row["id"])
                listings.append(row)
        following = next_start_index(soup, start)
        if following is None:
            return listings
        start = following

listings = crawl(session, "ats3", "oa002067")
print(f"{len(listings)} vacancies in total")

def text_of(soup, selector: str) -> str | None:
    node = soup.select_one(selector)
    return normalize(node.get_text()) if node else None

def fetch_detail(session: requests.Session, listing: dict) -> dict | None:
    response = session.get(listing["listing_url"], timeout=30)
    if response.status_code in (404, 410):
        return None  # canonical removal
    response.raise_for_status()
    soup = BeautifulSoup(response.text, "html.parser")

    title = text_of(soup, ".job-header .job-name")
    if not title:
        # Unknown JOB_ID: the shell renders with an empty title and no job header.
        return None

    number = text_of(soup, ".job-details .job-number .value")
    if number and number != listing["id"]:
        raise RuntimeError("PowerSchool detail job number disagreed with the requested JOB_ID")

    body = soup.select_one("div.message.job-description .richtextarea") \
           or soup.select_one("div.message.job-description")
    return {
        **listing,
        "title": title,
        "employer": text_of(soup, ".job-header .job-location"),
        "category": text_of(soup, ".job-header .job-description"),
        "city": text_of(soup, ".job-address .city"),
        "state": text_of(soup, ".job-address .state"),
        "postal_code": text_of(soup, ".job-address .zip"),
        "posted_at": text_of(soup, ".job-details .job-open-date .value") or listing["posted_at"],
        "closes_at": text_of(soup, ".job-details .job-close-date .value") or listing["closes_at"],
        "description_html": body.decode_contents().strip() if body else None,
    }

for listing in listings[:3]:
    job = fetch_detail(session, listing)
    print(job["title"] if job else f"{listing['id']} is no longer posted")