Lever Jobs API.

import re

# Lever boards live on two shards:
#   US: https://jobs.lever.co/{company}
#   EU: https://jobs.eu.lever.co/{company}
# A single pattern captures the slug from either host.
url = "https://jobs.lever.co/spotify"
match = re.search(r"jobs\.(?:eu\.)?lever\.co/([^/?#]+)", url)

if match:
    company_slug = match.group(1)
    print(f"Company slug: {company_slug}")  # "spotify"
else:
    print("Invalid Lever URL")

import requests

US_API_HOST = "api.lever.co"
EU_API_HOST = "api.eu.lever.co"

def get_lever_jobs(company_slug: str, eu_shard: bool = False) -> list:
    """Fetch every posting from a Lever board in a single request.

    EU tenants (jobs.eu.lever.co) must be queried on api.eu.lever.co;
    US tenants use api.lever.co. A 404 on one shard does not always mean
    the company is gone — tenants migrate between US and EU.
    """
    api_host = EU_API_HOST if eu_shard else US_API_HOST
    url = f"https://{api_host}/v0/postings/{company_slug}?mode=json"

    response = requests.get(url, timeout=10)
    if response.status_code == 404:
        raise ValueError(f'Company "{company_slug}" not found on {api_host}')

    response.raise_for_status()
    return response.json()

# Usage
jobs = get_lever_jobs("spotify")
print(f"Found {len(jobs)} jobs")

from datetime import datetime, timezone

def parse_lever_job(job: dict) -> dict:
    """Parse a single Lever posting into a flat structure."""
    categories = job.get("categories", {})
    salary = job.get("salaryRange")
    created_at = job.get("createdAt")

    return {
        "id": job.get("id"),
        "title": job.get("text"),
        "location": categories.get("location"),
        "all_locations": categories.get("allLocations") or [categories.get("location")],
        "department": categories.get("department"),
        "team": categories.get("team"),
        "employment_type": categories.get("commitment"),
        "workplace_type": job.get("workplaceType"),  # remote / hybrid / onsite
        "description_plain": job.get("descriptionPlain"),
        "description_html": job.get("description"),
        "description_body": job.get("descriptionBody"),
        "opening": job.get("opening"),
        "additional": job.get("additional"),  # benefits / perks
        "lists": job.get("lists", []),         # structured requirements
        "salary": {
            "min": salary.get("min"),
            "max": salary.get("max"),
            "currency": salary.get("currency"),
            "interval": salary.get("interval"),
        } if salary else None,
        "apply_url": job.get("applyUrl"),
        "view_url": job.get("hostedUrl"),
        "country": job.get("country"),
        # Lever's createdAt is a Unix timestamp in milliseconds.
        "posted_at": datetime.fromtimestamp(created_at / 1000, tz=timezone.utc) if created_at else None,
    }

jobs = get_lever_jobs("spotify")
parsed = [parse_lever_job(job) for job in jobs]
print(parsed[0])

def build_full_description(job: dict) -> str:
    """Reassemble a complete HTML description from Lever's sections."""
    parts = []

    # opening + descriptionBody is the structured pair; otherwise fall back
    # to description alone. Mixing description with descriptionBody would
    # duplicate the body, which is already inside description.
    if job.get("opening"):
        parts.append(job["opening"])
        if job.get("descriptionBody"):
            parts.append(job["descriptionBody"])
    elif job.get("description"):
        parts.append(job["description"])
    elif job.get("descriptionBody"):
        parts.append(job["descriptionBody"])

    # Structured lists: requirements, responsibilities, etc.
    for lst in job.get("lists", []):
        if lst.get("text"):
            parts.append(f"<h3>{lst['text']}</h3>")
        if lst.get("content"):
            parts.append(f"<ul>{lst['content']}</ul>")

    # Benefits / perks
    if job.get("additional"):
        parts.append(job["additional"])

    return "\n".join(p for p in parts if p)

for job in jobs:
    html = build_full_description(job)
    print(f"{job.get('text')}: {len(html)} chars")

import time

def scrape_many(slugs: list, delay_seconds: float = 1.0) -> dict:
    """Scrape several Lever boards back-to-back, one request at a time.

    Lever's robots.txt sets a 1-second crawl-delay, so keep a single
    in-flight request per board and pause between companies.
    """
    results = {}
    for slug in slugs:
        try:
            jobs = get_lever_jobs(slug)
            results[slug] = {"jobs": jobs, "error": None}
            print(f"[OK]   {slug}: {len(jobs)} jobs")
        except ValueError:
            results[slug] = {"jobs": [], "error": "not_found"}
            print(f"[SKIP] {slug}: not found")
        except requests.RequestException as exc:
            results[slug] = {"jobs": [], "error": str(exc)}
            print(f"[ERR]  {slug}: {exc}")

        time.sleep(delay_seconds)  # respect robots.txt crawl-delay

    return results

companies = ["spotify", "aircall", "actian", "anchorage"]
results = scrape_many(companies)
print(f"Total jobs: {sum(len(r['jobs']) for r in results.values())}")