Zoho Recruit Jobs API.

import re

# Zoho Recruit boards live on three regional TLDs; the tenant is the subdomain.
JOB_ID_RE = re.compile(r"jobs/Careers/(\d+)", re.I)

def board_url(tenant: str, tld: str = "com") -> str:
    """Careers board URL for a tenant. tld is one of: com | in | eu."""
    return f"https://{tenant}.zohorecruit.{tld}/jobs/Careers"

def extract_job_id(url: str) -> str | None:
    """Job IDs are the numeric segment after /jobs/Careers/."""
    m = JOB_ID_RE.search(url)
    return m.group(1) if m else None

# Usage
print(board_url("flintex"))                 # .com tenant
print(board_url("overturerede", "in"))      # India tenant
print(extract_job_id("https://flintex.zohorecruit.com/jobs/Careers/123456/Senior-Engineer"))

import requests

HEADERS = {"User-Agent": "Mozilla/5.0 (compatible; JoboBot/1.0)"}

def fetch_html(url: str) -> str:
    """Fetch a Zoho Recruit page. 403/429 mean throttling; back off and retry."""
    resp = requests.get(url, headers=HEADERS, timeout=15)
    if resp.status_code in (403, 429):
        raise RuntimeError(f"Rate limited ({resp.status_code}) - slow down and retry")
    resp.raise_for_status()  # 404 => tenant or job no longer exists
    return resp.text

html = fetch_html(board_url("flintex"))
print(f"Fetched {len(html)} bytes")

import html as html_lib
import json
import re

def _hidden_jobs_json(page: str) -> str | None:
    """Value of <input id="jobs" ...>, which holds HTML-entity-encoded JSON."""
    idx = page.find('id="jobs"')
    if idx == -1:
        idx = page.find("id='jobs'")
    if idx == -1:
        return None
    # Isolate the surrounding <input> tag so we never regex the whole 2 MB page.
    start = page.rfind("<input", 0, idx)
    end = page.find(">", idx)
    if start == -1 or end == -1:
        return None
    tag = page[start:end + 1]
    m = re.search(r'value\s*=\s*"([^"]*)"', tag, re.S)
    return html_lib.unescape(m.group(1)) if m else None

def _script_jobs_json(page: str) -> str | None:
    """Fallback: the var jobs = JSON.parse('...') inline script (JS-escaped)."""
    start_marker, end_marker = "var jobs = JSON.parse('", "');"
    i = page.find(start_marker)
    if i == -1:
        return None
    i += len(start_marker)
    j = page.find(end_marker, i)
    if j == -1:
        return None
    raw = page[i:j].replace('\\/', '/').replace('\\"', '"')
    return re.sub(r'\\u([0-9a-fA-F]{4})', lambda m: chr(int(m.group(1), 16)), raw)

def extract_jobs(page: str) -> list[dict]:
    """Try the hidden input first, then the inline script fallback."""
    for candidate in (_hidden_jobs_json(page), _script_jobs_json(page)):
        if not candidate:
            continue
        try:
            data = json.loads(candidate)
            if data:
                return data
        except json.JSONDecodeError:
            continue
    return []

jobs = extract_jobs(html)
print(f"Found {len(jobs)} openings")

import re

_TITLE_STRIP = re.compile(r"[^A-Za-z0-9\s-]")

def slugify_title(title: str) -> str:
    """Zoho detail URLs append a sanitized title slug after the job ID."""
    s = _TITLE_STRIP.sub("", title)
    s = re.sub(r"\s+", "-", s)
    s = re.sub(r"-{2,}", "-", s).strip("-")
    return s

def map_job(job: dict, board: str) -> dict:
    job_id = (job.get("id") or "").strip()
    title = (job.get("Job_Opening_Name") or job.get("Posting_Title") or "").strip()
    parts = [job.get(k, "").strip() for k in ("City", "State", "Country") if job.get(k)]
    location = ", ".join(p for p in parts if p) or ("Remote" if job.get("Remote_Job") else None)
    # Free-text "Salary" is the fallback when Min/Max are empty.
    salary = job.get("Min_Salary") or job.get("Max_Salary") or job.get("Salary")
    return {
        "id": job_id,
        "title": title,
        "location": location,
        "job_type": job.get("Job_Type"),
        "industry": job.get("Industry"),
        "date_opened": job.get("Date_Opened"),
        "currency": job.get("Currency"),
        "salary": salary,
        "url": f"{board.rstrip('/')}/{job_id}/{slugify_title(title)}",
    }

board = board_url("flintex")
listings = [map_job(j, board) for j in jobs]
for job in listings[:3]:
    print(f"  - {job['title']} ({job['location']}) -> {job['url']}")

from bs4 import BeautifulSoup

def fetch_job_detail(detail_url: str) -> dict:
    """Prefer the embedded JSON (matched by ID); fall back to on-page selectors."""
    page = fetch_html(detail_url)
    job_id = extract_job_id(detail_url)
    board = detail_url.rsplit("/", 2)[0]

    for job in extract_jobs(page):
        if job.get("id") == job_id:
            return map_job(job, board) | {"description": job.get("Job_Description")}

    # Fallback selectors used when the embedded JSON is absent.
    soup = BeautifulSoup(page, "html.parser")
    title_el = soup.select_one("h1") or soup.select_one("title")
    desc_el = soup.select_one("div.cw-jobdesc, div.job-description, div.cw-editor-content")
    return {
        "url": detail_url,
        "title": title_el.get_text(strip=True) if title_el else None,
        "description": desc_el.get_text("\n", strip=True) if desc_el else None,
    }

details = fetch_job_detail(listings[0]["url"])
print(f"Title: {details['title']}")