SeeMeHired Jobs API.

from urllib.parse import urlparse

PUBLIC_HOST = "seemehired.com"

def parse_seemehired(url: str) -> dict:
    parsed = urlparse(url)
    if parsed.netloc.lower() != PUBLIC_HOST:
        raise ValueError("not a SeeMeHired URL")

    parts = [p for p in parsed.path.strip("/").split("/") if p]
    if len(parts) == 2 and parts[0] == "jobs" and parts[1].isdigit():
        return {"kind": "job", "job_id": parts[1]}
    if len(parts) == 2 and parts[0] == "opportunities":
        return {"kind": "board", "slug": parts[1]}
    raise ValueError("unrecognised SeeMeHired route")

print(parse_seemehired("https://seemehired.com/jobs/68594"))
# {'kind': 'job', 'job_id': '68594'}

import requests

API = "https://api.seemehired.com/public"

def resolve_employer(job_id: str, session: requests.Session) -> dict | None:
    job = session.get(f"{API}/jobs/{job_id}", timeout=30)
    if job.status_code in (404, 410):
        return None  # the posting is gone
    job.raise_for_status()
    record = job.json()

    employer_id = record.get("employerId")
    if not isinstance(employer_id, int) or employer_id <= 0:
        return None

    company = session.get(f"{API}/companies/{employer_id}", timeout=30)
    company.raise_for_status()
    return {
        "employer_id": employer_id,
        "slug": company.json().get("slug"),
        "job_token": record.get("jobToken"),
    }

session = requests.Session()
print(resolve_employer("68594", session))

def verified_slug(employer_id: int, session: requests.Session) -> str:
    resp = session.get(f"{API}/companies/{employer_id}", timeout=30)
    resp.raise_for_status()
    slug = resp.json().get("slug")
    if not slug:
        raise RuntimeError(f"employer {employer_id} no longer publishes a slug")
    return slug

def listings_url(slug: str, page: int) -> str:
    return (
        f"{API}/jobs/search/paginated"
        f"?companySlug={slug}&locationMatch=exact&limit=500"
        f"&page={page}&internalJobs=false"
    )

slug = verified_slug(304, session)   # Abicare
print(listings_url(slug, 1))

def fetch_board(employer_id: int, slug: str, session: requests.Session) -> list[dict]:
    collected, page = [], 1
    while True:
        resp = session.get(listings_url(slug, page), timeout=30)
        resp.raise_for_status()
        payload = resp.json()

        rows = payload.get("jobs") or payload.get("results") or []
        total = payload.get("total")

        for row in rows:
            if row.get("employerId") != employer_id:
                raise RuntimeError(
                    "search returned a foreign employer — this is the unknown-slug "
                    "fallback, not this board. Abort instead of expiring jobs."
                )
            collected.append(row)

        if not rows or (total is not None and len(collected) >= total):
            return collected
        page += 1

jobs = fetch_board(304, slug, session)
print(f"{len(jobs)} rows for employer 304")

import time

def hydrate(job_id: str, employer_id: int, session: requests.Session) -> dict:
    resp = session.get(f"{API}/jobs/{job_id}", timeout=30)
    if resp.status_code in (404, 410):
        return {"id": job_id, "state": "removed"}
    resp.raise_for_status()
    record = resp.json()

    if record.get("employerId") != employer_id:
        raise RuntimeError("detail contradicted the listing employer")

    if not record.get("isActive") or record.get("closed") or record.get("isJobInternal"):
        return {"id": job_id, "state": "unavailable"}

    return {
        "id": job_id,
        "state": "active",
        "title": record.get("title"),
        "description_html": record.get("description"),
        "listing_url": f"https://seemehired.com/jobs/{job_id}",
        "apply_url": f"https://seemehired.com/jobs/{slug}/{job_id}?company={slug}",
    }

for row in jobs[:3]:
    print(hydrate(str(row["id"]), 304, session)["state"])
    time.sleep(0.1)