Jobsoid Jobs API.

import re
from urllib.parse import urlparse

SUFFIX = ".jobsoid.com"
RESERVED = {"portal", "www", "api", "portal-api"}
TENANT = re.compile(r"^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$", re.IGNORECASE)
JOB_ID = re.compile(r"^[1-9][0-9]*$")

def parse_hosted(url: str) -> tuple[str, str | None] | None:
    parsed = urlparse(url)
    host = parsed.netloc.lower()
    if not host.endswith(SUFFIX):
        return None
    tenant = host[: -len(SUFFIX)]
    if tenant in RESERVED or "." in tenant or not TENANT.match(tenant):
        return None

    parts = [p for p in parsed.path.split("/") if p]
    if not parts or parts == ["jobs"]:
        return tenant, None                                   # the board
    if parts[0] in ("j", "apply") and JOB_ID.match(parts[1] if len(parts) > 1 else ""):
        return tenant, parts[1]
    return None

def board_url(tenant: str) -> str:
    return f"https://{tenant}.jobsoid.com/"

print(parse_hosted("https://webbeds.jobsoid.com/j/136095/market-manager-korea"))

import requests

def fetch_jobs(session: requests.Session, tenant: str) -> list[dict]:
    response = session.get(
        f"https://{tenant}.jobsoid.com/api/v1/jobs",
        headers={"Accept": "application/json"},
        timeout=60,
    )
    response.raise_for_status()
    rows = response.json()
    if not isinstance(rows, list):
        raise RuntimeError("Jobsoid listings API omitted its array")
    return rows  # [] is an authoritative empty board

session = requests.Session()
rows = fetch_jobs(session, "winterberry")
print(f"{len(rows)} published jobs")

def build_location(location: dict | None) -> str | None:
    if not location:
        return None
    parts = [location.get("title") or location.get("city"),
             location.get("state"), location.get("country")]
    return ", ".join(p for p in parts if p) or None

def map_row(row: dict, tenant: str) -> dict | None:
    job_id, slug, title = row.get("id"), (row.get("slug") or "").lower(), (row.get("title") or "").strip()
    if not job_id or not slug or not title:
        return None

    apply_url = (row.get("applyUrl") or "").strip()
    if not apply_url.startswith("https://"):
        apply_url = f"https://{tenant}.jobsoid.com/apply/{job_id}"

    return {
        "id": str(job_id),
        "title": title,
        "company": (row.get("company") or "").strip() or None,
        "description_html": (row.get("description") or "").strip() or None,
        "location": build_location(row.get("location")),
        "department": (row.get("department") or {}).get("title"),
        "function": (row.get("function") or {}).get("title"),
        "job_code": row.get("code"),
        "job_type": row.get("type"),
        "positions": row.get("positions"),
        "experience": row.get("experience"),
        "salary": row.get("salary"),
        "posted_at": row.get("postedDate"),
        "closes_at": row.get("closingDate"),
        "listing_url": f"https://{tenant}.jobsoid.com/j/{job_id}/{slug}",
        "apply_url": apply_url,
    }

listings = [m for m in (map_row(r, "winterberry") for r in rows) if m]
print(f"{len(listings)} mapped of {len(rows)} received")

def fetch_job(session: requests.Session, tenant: str, job_id: str) -> dict | None:
    response = session.get(
        f"https://{tenant}.jobsoid.com/api/v1/jobs/{job_id}",
        headers={"Accept": "application/json"},
        timeout=30,
    )
    # 204 is Jobsoid's canonical "no longer published" answer, alongside 404/410.
    if response.status_code in (204, 404, 410):
        return None
    response.raise_for_status()

    row = response.json()
    if str(row.get("id")) != str(job_id):
        raise RuntimeError("Jobsoid detail API contradicted the requested job id")
    return map_row(row, tenant)

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

PROOF = re.compile(
    r'"job"\s*:\s*\{\s*"id"\s*:\s*([1-9][0-9]*)'
    r'[\s\S]{0,200000}?"tenantDomainSlug"\s*:\s*"([a-z0-9][a-z0-9-]{0,61})"',
    re.IGNORECASE,
)

def resolve_tenant(session: requests.Session, job_id: str) -> str | None:
    response = session.get(
        f"https://portal.jobsoid.com/j/{job_id}",
        headers={"Accept": "text/html,application/xhtml+xml"},
        timeout=30,
    )
    if not response.ok:
        return None
    match = PROOF.search(response.text)
    # Jobsoid renders an explicit "Job Not Found" surface with no tenant at all.
    if not match or match.group(1) != str(job_id):
        return None
    return match.group(2).lower()

print(resolve_tenant(session, "131929"))