Teamtailor Jobs API.

from urllib.parse import urlparse

def extract_company_subdomain(url: str) -> str:
    """Extract the company subdomain from a Teamtailor URL."""
    parsed = urlparse(url)
    hostname = parsed.hostname or ""

    # Handle regional subdomains like .na.teamtailor.com
    if ".na.teamtailor.com" in hostname:
        return hostname.replace(".na.teamtailor.com", "")
    elif ".teamtailor.com" in hostname:
        return hostname.replace(".teamtailor.com", "")
    return hostname

# Examples
print(extract_company_subdomain("https://polestar.teamtailor.com/jobs"))  # polestar
print(extract_company_subdomain("https://klarna.teamtailor.com"))  # klarna

import requests

company = "polestar"
rss_url = f"https://{company}.teamtailor.com/jobs.rss"

headers = {
    "Accept": "application/rss+xml, application/xml, text/xml",
    "User-Agent": "JobScraper/1.0"
}

response = requests.get(rss_url, headers=headers, timeout=30)
response.raise_for_status()

rss_content = response.text

# Verify it's valid RSS
if "<rss" not in rss_content:
    print("Warning: RSS feed not available, may need HTML fallback")
else:
    print(f"Fetched {len(rss_content)} bytes of RSS data")

import xml.etree.ElementTree as ET
from html import unescape
import re

def parse_rss_feed(rss_content: str) -> list[dict]:
    """Parse Teamtailor RSS feed and extract job listings."""
    root = ET.fromstring(rss_content)
    channel = root.find("channel")

    jobs = []
    for item in channel.findall("item"):
        # Extract basic fields
        title = item.findtext("title", "")
        description = item.findtext("description", "")
        link = item.findtext("link", "")
        pub_date = item.findtext("pubDate")

        # Custom Teamtailor fields
        remote_status = item.findtext("remoteStatus", "none")
        company_name = item.findtext("company_name", "")

        # Extract job ID from URL pattern: /jobs/{id}-{slug}
        id_match = re.search(r"/jobs/(\d+)", link)
        job_id = id_match.group(1) if id_match else None

        # Decode HTML entities in description
        description = unescape(description)

        jobs.append({
            "id": job_id,
            "title": title,
            "url": link,
            "description_html": description,
            "published_at": pub_date,
            "remote_status": remote_status,
            "company": company_name,
        })

    return jobs

jobs = parse_rss_feed(rss_content)
print(f"Found {len(jobs)} jobs")

def extract_namespaced_data(item: ET.Element) -> dict:
    """Extract location and department data from Teamtailor namespace."""
    TT_NS = "{https://teamtailor.com/locations}"

    # Extract department
    department_elem = item.find(f"{TT_NS}department")
    department = department_elem.text.strip() if department_elem is not None and department_elem.text else None

    # Extract locations
    locations = []
    locations_elem = item.find(f"{TT_NS}locations")
    if locations_elem is not None:
        for loc in locations_elem.findall(f"{TT_NS}location"):
            name_elem = loc.find(f"{TT_NS}name")
            city_elem = loc.find(f"{TT_NS}city")
            country_elem = loc.find(f"{TT_NS}country")

            if name_elem is not None and name_elem.text:
                locations.append(name_elem.text.strip())
            elif city_elem is not None or country_elem is not None:
                city = city_elem.text.strip() if city_elem is not None and city_elem.text else ""
                country = country_elem.text.strip() if country_elem is not None and country_elem.text else ""
                if city or country:
                    locations.append(f"{city}, {country}".strip(", "))

    return {
        "department": department,
        "locations": locations,
    }

# Usage in parsing loop
for job in jobs:
    item = channel.find(f".//item[link='{job['url']}']")
    if item is not None:
        extra_data = extract_namespaced_data(item)
        job["department"] = extra_data["department"]
        job["locations"] = extra_data["locations"]

import time
from typing import Optional

def fetch_teamtailor_jobs(company: str, max_retries: int = 3) -> Optional[list[dict]]:
    """Fetch all jobs from a Teamtailor company with error handling."""
    rss_url = f"https://{company}.teamtailor.com/jobs.rss"

    for attempt in range(max_retries):
        try:
            response = requests.get(
                rss_url,
                headers={"User-Agent": "JobScraper/1.0"},
                timeout=30
            )
            response.raise_for_status()

            if "<rss" in response.text:
                return parse_rss_feed(response.text)
            else:
                print(f"Invalid RSS format for {company}")
                return None

        except requests.HTTPError as e:
            if e.response.status_code == 404:
                print(f"Company '{company}' not found")
                return None
            elif e.response.status_code == 429:
                wait_time = 2 ** attempt
                print(f"Rate limited, waiting {wait_time}s...")
                time.sleep(wait_time)
            else:
                print(f"HTTP error: {e}")
                return None

        except requests.RequestException as e:
            print(f"Request failed: {e}")
            if attempt < max_retries - 1:
                time.sleep(1)

    return None

# Batch fetch multiple companies with rate limiting
companies = ["polestar", "klarna", "spotify"]
for company in companies:
    jobs = fetch_teamtailor_jobs(company)
    if jobs:
        print(f"{company}: {len(jobs)} jobs")
    time.sleep(0.5)  # Be respectful between requests