SmartRecruiters Jobs API.

import re

def extract_company_id(url: str) -> str:
    """Extract company identifier from SmartRecruiters URL."""
    patterns = [
        r'jobs\.smartrecruiters\.com/([^/?]+)',
        r'careers\.smartrecruiters\.com/([^/?]+)',
        r'api\.smartrecruiters\.com/v1/companies/([^/?]+)',
    ]

    for pattern in patterns:
        match = re.search(pattern, url)
        if match:
            return match.group(1)

    raise ValueError(f'Could not extract company ID from {url}')

# Example usage
url = "https://jobs.smartrecruiters.com/Visa"
company_id = extract_company_id(url)
print(f"Company ID: {company_id}")  # Output: Visa

import requests
import time

def fetch_all_jobs(company_id: str, page_size: int = 100) -> list[dict]:
    """Fetch all job listings for a company with pagination."""
    all_jobs = []
    offset = 0
    base_url = f"https://api.smartrecruiters.com/v1/companies/{company_id}/postings"

    while True:
        params = {"limit": page_size, "offset": offset}
        response = requests.get(base_url, params=params, timeout=30)
        response.raise_for_status()

        data = response.json()
        jobs = data.get("content", [])
        all_jobs.extend(jobs)

        total_found = data.get("totalFound", 0)
        print(f"Fetched {len(jobs)} jobs (total: {total_found}, offset: {offset})")

        # Check if we've fetched all jobs
        if len(all_jobs) >= total_found or len(jobs) < page_size:
            break

        offset += page_size
        time.sleep(0.1)  # Be respectful with rate limiting

    return all_jobs

# Example usage
jobs = fetch_all_jobs("AFCA")
print(f"Total jobs found: {len(jobs)}")

import requests

def fetch_job_details(company_id: str, job_id: str) -> dict:
    """Fetch full details for a specific job posting."""
    url = f"https://api.smartrecruiters.com/v1/companies/{company_id}/postings/{job_id}"

    response = requests.get(url, timeout=30)
    response.raise_for_status()

    job = response.json()

    return {
        "id": job.get("id"),
        "title": job.get("name"),
        "posting_url": job.get("postingUrl"),
        "apply_url": job.get("applyUrl"),
        "description": job.get("jobAd", {}).get("sections", {}).get("jobDescription", {}).get("text", ""),
        "qualifications": job.get("jobAd", {}).get("sections", {}).get("qualifications", {}).get("text", ""),
        "company_description": job.get("jobAd", {}).get("sections", {}).get("companyDescription", {}).get("text", ""),
        "location": job.get("location", {}).get("fullLocation"),
        "city": job.get("location", {}).get("city"),
        "country": job.get("location", {}).get("country"),
        "remote": job.get("location", {}).get("remote", False),
        "hybrid": job.get("location", {}).get("hybrid", False),
        "department": job.get("department", {}).get("label"),
        "employment_type": job.get("typeOfEmployment", {}).get("label"),
        "experience_level": job.get("experienceLevel", {}).get("label"),
        "compensation": job.get("compensation"),
        "posted_date": job.get("releasedDate"),
        "custom_fields": job.get("customField", []),
    }

# Example usage
job = fetch_job_details("AFCA", "744000107175576")
print(f"Job: {job['title']}")
print(f"Location: {job['location']}")

import requests

def validate_company(company_id: str) -> dict:
    """Validate a company identifier and check for active jobs."""
    url = f"https://api.smartrecruiters.com/v1/companies/{company_id}/postings"
    params = {"limit": 1, "offset": 0}

    try:
        response = requests.get(url, params=params, timeout=30)
        response.raise_for_status()
        data = response.json()

        total_found = data.get("totalFound", 0)

        if total_found == 0:
            return {"valid": False, "reason": "No jobs found or invalid company"}

        # Get company name from first posting
        company_name = None
        if data.get("content"):
            company_name = data["content"][0].get("company", {}).get("name")

        return {
            "valid": True,
            "total_jobs": total_found,
            "company_name": company_name,
        }
    except requests.RequestException as e:
        return {"valid": False, "reason": str(e)}

# Example usage
result = validate_company("Visa")
print(result)  # {'valid': True, 'total_jobs': 150, 'company_name': 'Visa'}

result = validate_company("InvalidCompany123")
print(result)  # {'valid': False, 'reason': 'No jobs found or invalid company'}

import requests
import time
from typing import Optional

def fetch_with_retry(
    url: str,
    params: dict = None,
    max_retries: int = 3,
    delay: float = 0.2
) -> Optional[dict]:
    """Fetch URL with retry logic and rate limiting."""
    for attempt in range(max_retries):
        try:
            time.sleep(delay)  # Rate limiting
            response = requests.get(url, params=params, timeout=30)

            if response.status_code == 404:
                print(f"Resource not found: {url}")
                return None

            if response.status_code == 429:
                # Rate limited - wait longer
                wait_time = 2 ** attempt
                print(f"Rate limited, waiting {wait_time}s...")
                time.sleep(wait_time)
                continue

            response.raise_for_status()
            return response.json()

        except requests.RequestException as e:
            print(f"Attempt {attempt + 1} failed: {e}")
            if attempt == max_retries - 1:
                raise

    return None

# Example usage with caching via ETag
cached_etags = {}

def fetch_with_cache(url: str) -> dict:
    """Fetch with ETag-based caching."""
    headers = {}
    if url in cached_etags:
        headers["If-None-Match"] = cached_etags[url]

    response = requests.get(url, headers=headers, timeout=30)

    if response.status_code == 304:
        print("Using cached response")
        return None  # Return cached data

    if response.ok:
        if "ETag" in response.headers:
            cached_etags[url] = response.headers["ETag"]
        return response.json()

    response.raise_for_status()