Workday Jobs API.

import re

def parse_workday_url(url: str) -> dict:
    """Extract tenant and site from a Workday URL."""
    # Pattern: https://{tenant}.wd{N}.myworkdayjobs.com/{locale}/{site}
    match = re.match(
        r'https://([^.]+).wdd+.myworkdayjobs.com/(?:[a-z]{2}-[A-Z]{2}/)?([^/]+)',
        url
    )
    if match:
        return {
            "tenant": match.group(1),
            "site": match.group(2),
            "base_url": url.rstrip('/').split('/job/')[0]
        }
    # Handle myworkdaysite.com format
    match = re.match(
        r'https://jobs.myworkdaysite.com/recruiting/([^/]+)/([^/]+)',
        url
    )
    if match:
        return {
            "tenant": match.group(1),
            "site": match.group(2),
            "base_url": url.split('/job/')[0]
        }
    return None

# Example usage
url = "https://kainos.wd3.myworkdayjobs.com/en-US/kainos"
config = parse_workday_url(url)
print(config)  # {'tenant': 'kainos', 'site': 'kainos', 'base_url': '...'}

import requests

def fetch_jobs_listings(tenant: str, site: str, wd_server: str = "wd3", limit: int = 20, offset: int = 0) -> dict:
    """Fetch job listings from Workday CXS API."""
    url = f"https://{tenant}.{wd_server}.myworkdayjobs.com/wday/cxs/{tenant}/{site}/jobs"

    headers = {
        "Accept": "application/json",
        "Content-Type": "application/json",
        "Accept-Language": "en-US",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        "Referer": f"https://{tenant}.{wd_server}.myworkdayjobs.com/en-US/{site}",
    }

    payload = {
        "appliedFacets": {},
        "limit": limit,
        "offset": offset,
        "searchText": ""
    }

    response = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()

# Fetch first page of jobs
data = fetch_jobs_listings("kainos", "kainos", wd_server="wd3", limit=20, offset=0)
print(f"Total jobs: {data.get('total', 0)}")
print(f"Jobs in this page: {len(data.get('jobPostings', []))}")

def parse_listings(data: dict) -> list:
    """Parse job listings from Workday API response."""
    jobs = []
    for posting in data.get("jobPostings", []):
        # Extract requisition ID from bulletFields
        req_id = None
        for field in posting.get("bulletFields", []):
            if field.startswith(("JR_", "REQ", "R-")):
                req_id = field
                break

        job = {
            "title": posting.get("title"),
            "external_path": posting.get("externalPath"),
            "locations": posting.get("locationsText"),
            "posted_on": posting.get("postedOn"),
            "requisition_id": req_id,
            "url": posting.get("externalUrl"),
        }
        jobs.append(job)
    return jobs

# Parse and display jobs
jobs = parse_listings(data)
for job in jobs[:3]:
    print(f"- {job['title']} ({job['requisition_id']}) at {job['locations']}")

import time

def fetch_all_jobs(tenant: str, site: str, wd_server: str = "wd3", batch_size: int = 20) -> list:
    """Fetch all jobs with pagination handling."""
    all_jobs = []
    offset = 0

    while True:
        data = fetch_jobs_listings(tenant, site, wd_server, limit=batch_size, offset=offset)
        postings = data.get("jobPostings", [])
        total = data.get("total", 0)

        if not postings:
            break

        all_jobs.extend(postings)
        print(f"Fetched {len(all_jobs)} of {total} jobs...")

        # Check if we've fetched all jobs
        if offset + batch_size >= total:
            break

        offset += batch_size
        time.sleep(1.5)  # Be respectful to the API

    return all_jobs

# Fetch all jobs for a company
all_jobs = fetch_all_jobs("kainos", "kainos", "wd3")
print(f"Total jobs fetched: {len(all_jobs)}")

def fetch_job_details(tenant: str, site: str, external_path: str, wd_server: str = "wd3") -> dict:
    """Fetch full details for a single job."""
    url = f"https://{tenant}.{wd_server}.myworkdayjobs.com/wday/cxs/{tenant}/{site}/job/{external_path}"

    headers = {
        "Accept": "application/json",
        "Accept-Encoding": "gzip, deflate, br",
        "Referer": f"https://{tenant}.{wd_server}.myworkdayjobs.com/en-US/{site}",
    }

    response = requests.get(url, headers=headers)
    response.raise_for_status()
    return response.json()

# Fetch details for a specific job
job_listings = fetch_jobs_listings("kainos", "kainos", limit=1)
if job_listings.get("jobPostings"):
    first_job = job_listings["jobPostings"][0]
    details = fetch_job_details("kainos", "kainos", first_job["externalPath"])

    print(f"Title: {details.get('title')}")
    print(f"Location: {details.get('location')}")
    print(f"Additional Locations: {details.get('additionalLocations', [])}")
    print(f"Time Type: {details.get('timeType')}")
    print(f"Job Req ID: {details.get('jobReqId')}")
    print(f"Start Date: {details.get('startDate')}")
    print(f"Description length: {len(details.get('jobDescription', ''))} chars")

import requests
from xml.etree import ElementTree

def fetch_sitemap(tenant: str, site: str, wd_server: str = "wd3") -> list:
    """Fetch job URLs from Workday sitemap."""
    # Note: siteMap.xml has capital S
    url = f"https://{tenant}.{wd_server}.myworkdayjobs.com/en-US/{site}/siteMap.xml"

    headers = {
        "Accept": "application/xml",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    }

    response = requests.get(url, headers=headers)
    response.raise_for_status()

    # Parse XML and extract job URLs
    root = ElementTree.fromstring(response.content)
    namespace = {'ns': 'http://www.sitemaps.org/schemas/sitemap/0.9'}

    job_urls = []
    for url_elem in root.findall('.//ns:url/ns:loc', namespace):
        loc = url_elem.text
        if '/job/' in loc:
            job_urls.append(loc)

    return job_urls

# Get all job URLs from sitemap
job_urls = fetch_sitemap("kainos", "kainos", "wd3")
print(f"Found {len(job_urls)} job URLs in sitemap")
for url in job_urls[:3]:
    print(f"  - {url}")