Logo
Supacrawler

Automate Job Search Monitoring

Stop manually checking career pages and get notified instantly when your dream companies post new job openings. This guide shows you how to automate job search monitoring across multiple companies using the Watch API.

Prerequisites

Quick example

Monitor a company's career page for new job postings:

curl -X POST https://api.supacrawler.com/api/v1/watch \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://careers.google.com/jobs/results",
    "frequency": "daily",
    "selector": ".gc-card__title, .job-title",
    "notify_email": "[email protected]",
    "notification_preference": "changes_only"
  }'

Multi-company monitoring

Set up monitoring for multiple companies at once:

import requests
import os

# Define target companies and their career pages
companies = [
    {
        "name": "Google",
        "url": "https://careers.google.com/jobs/results",
        "selector": ".gc-card__title"
    },
    {
        "name": "Microsoft", 
        "url": "https://careers.microsoft.com/professionals/us/en/search-results",
        "selector": ".job-title, .ms-List-item a"
    },
    {
        "name": "Apple",
        "url": "https://jobs.apple.com/en-us/search",
        "selector": ".table--advanced-search td a"
    },
    {
        "name": "Netflix",
        "url": "https://jobs.netflix.com/search",
        "selector": ".job-title-link"
    },
    {
        "name": "Stripe",
        "url": "https://stripe.com/jobs/search",
        "selector": ".JobsList__job-title"
    }
]

api_key = os.environ['SUPACRAWLER_API_KEY']
created_monitors = []

for company in companies:
    response = requests.post("https://api.supacrawler.com/api/v1/watch",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        },
        json={
            "url": company["url"],
            "frequency": "daily",
            "selector": company["selector"],
            "notify_email": f"jobs-{company['name'].lower()}@example.com",
            "notification_preference": "changes_only",
            
            # Rich context for job applications
            "include_image": True,
            "include_html": True,
            
            # Webhook for processing
            "webhook_url": "https://your-site.com/api/job-alerts",
            "webhook_headers": {
                "X-Company": company["name"],
                "X-Alert-Type": "new-job"
            }
        }
    )
    
    result = response.json()
    if result.get('success'):
        created_monitors.append({
            'company': company['name'],
            'watch_id': result['watch_id'],
            'url': company['url']
        })
        print(f"✅ {company['name']}: {result['watch_id']}")
    else:
        print(f"❌ {company['name']}: {result.get('error')}")

print(f"\n🎯 Monitoring {len(created_monitors)} companies for new job postings")

Career page layouts change frequently. Always inspect the target page to verify selectors before deploying monitors.

  • Name
    Google Careers
    Type
    .gc-card__title, .job-title
    Description

    Job title links on Google careers page

  • Name
    Microsoft Careers
    Type
    .ms-List-item a, .job-title
    Description

    Job listings in Microsoft's career portal

  • Name
    LinkedIn Jobs
    Type
    .job-search-card__title, .jobs-search__job-title
    Description

    Job title elements on LinkedIn job listings

  • Name
    Workday Sites
    Type
    li[role=listitem] a, .wd-entity-list-item-title
    Description

    Common selector for Workday-powered career sites

  • Name
    GitHub Jobs
    Type
    .job-title, .job-listing h3
    Description

    Job titles on GitHub's job board

Job filtering and targeting

Location-specific monitoring

Monitor jobs in specific locations or remote opportunities:

# Monitor for remote and San Francisco jobs
location_filters = [
    {
        "location": "Remote",
        "url": "https://careers.company.com/jobs?location=remote",
        "selector": ".job-card-title"
    },
    {
        "location": "San Francisco",  
        "url": "https://careers.company.com/jobs?location=san-francisco",
        "selector": ".job-card-title"
    },
    {
        "location": "New York",
        "url": "https://careers.company.com/jobs?location=new-york", 
        "selector": ".job-card-title"
    }
]

for location_config in location_filters:
    requests.post("https://api.supacrawler.com/api/v1/watch",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "url": location_config["url"],
            "frequency": "daily",
            "selector": location_config["selector"],
            "notify_email": f"jobs-{location_config['location'].lower().replace(' ', '-')}@example.com",
            "webhook_headers": {
                "X-Location": location_config["location"],
                "X-Job-Type": "location-filtered"
            }
        }
    )

Role-specific monitoring

Target specific job roles or departments:

# Monitor specific job categories
role_filters = [
    {
        "role": "Engineering",
        "url": "https://careers.company.com/engineering",
        "keywords": ["engineer", "developer", "software", "backend", "frontend"]
    },
    {
        "role": "Product Management",
        "url": "https://careers.company.com/product",  
        "keywords": ["product manager", "pm", "product", "strategy"]
    },
    {
        "role": "Data Science",
        "url": "https://careers.company.com/data",
        "keywords": ["data scientist", "analyst", "machine learning", "ai"]
    }
]

for role_config in role_filters:
    requests.post("https://api.supacrawler.com/api/v1/watch",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "url": role_config["url"],
            "frequency": "daily", 
            "selector": ".job-title, .position-title",
            "notify_email": f"jobs-{role_config['role'].lower().replace(' ', '-')}@example.com",
            "webhook_url": "https://your-site.com/api/role-specific-jobs",
            "webhook_headers": {
                "X-Role": role_config["role"],
                "X-Keywords": ",".join(role_config["keywords"])
            }
        }
    )

Best practices

Monitoring frequency

Choose appropriate check frequencies based on company size and hiring speed:

  • Daily: Most companies, balanced between timeliness and resource usage
  • Every 12 hours: Fast-growing startups, competitive roles
  • Every 2-3 days: Large enterprises with slower hiring cycles
  • Weekly: Companies you're monitoring for future opportunities

Reliable selectors

  • Focus on job title elements that are consistent across page updates
  • Avoid selectors that depend on dynamic content or job counts
  • Test selectors on multiple job listings to ensure they capture all postings
  • Have backup selectors ready for when sites redesign their career pages

Application speed optimization

  • Set up webhook notifications for instant alerts instead of waiting for email
  • Use screenshot capture to quickly assess job descriptions
  • Configure different alert channels for different priority levels
  • Automate initial application steps where possible

Integration examples

Slack notifications

from flask import Flask, request
import requests
import json

app = Flask(__name__)

@app.route('/api/job-alerts', methods=['POST'])
def handle_job_alert():
    """Process job alerts and send to Slack"""
    
    data = request.json
    company = data.get('headers', {}).get('X-Company', 'Unknown')
    
    # Extract new job information
    new_jobs = data.get('changes', [])
    
    for job_change in new_jobs:
        if job_change.get('type') == 'added':
            job_title = job_change.get('content', 'New Job Posted')
            
            # Send to Slack
            slack_payload = {
                "text": f"🎯 New Job Alert: {company}",
                "attachments": [
                    {
                        "color": "good",
                        "fields": [
                            {"title": "Company", "value": company, "short": True},
                            {"title": "Position", "value": job_title, "short": True},
                            {"title": "Career Page", "value": data.get('url'), "short": False},
                            {"title": "Screenshot", "value": data.get('screenshot_url', 'N/A'), "short": False}
                        ],
                        "actions": [
                            {
                                "type": "button",
                                "text": "View Job",
                                "url": data.get('url')
                            }
                        ]
                    }
                ]
            }
            
            requests.post(SLACK_WEBHOOK_URL, json=slack_payload)
    
    return {"status": "processed"}

Application tracking

# Webhook handler that logs jobs to a tracking system
@app.route('/api/job-tracker', methods=['POST'])
def track_new_jobs():
    """Track new job postings for application management"""
    
    data = request.json
    company = data.get('headers', {}).get('X-Company')
    role_type = data.get('headers', {}).get('X-Role')
    
    # Extract job details
    for change in data.get('changes', []):
        if change.get('type') == 'added':
            job_data = {
                'company': company,
                'role_type': role_type,
                'title': change.get('content'),
                'career_page_url': data.get('url'),
                'screenshot_url': data.get('screenshot_url'),
                'discovered_at': data.get('timestamp'),
                'application_status': 'discovered',
                'priority': calculate_priority(company, change.get('content'))
            }
            
            # Save to database
            save_job_opportunity(job_data)
            
            # Send priority notifications
            if job_data['priority'] == 'high':
                send_urgent_notification(job_data)
    
    return {"status": "tracked"}

def calculate_priority(company, job_title):
    """Calculate job priority based on company and role"""
    high_priority_companies = ['Google', 'Apple', 'Microsoft', 'Netflix']
    target_keywords = ['senior', 'lead', 'principal', 'staff']
    
    if company in high_priority_companies:
        return 'high'
    
    if any(keyword in job_title.lower() for keyword in target_keywords):
        return 'high'
    
    return 'normal'

Next steps

  • Interview preparation: Set up monitoring for company blogs and news for interview insights
  • Salary research: Monitor compensation discussion sites for salary data
  • Network building: Track employee changes and company growth for networking opportunities
  • Application optimization: A/B test different application approaches based on monitoring insights
  • Career planning: Use monitoring data to identify hiring trends and skill demands

Was this page helpful?