Introduction
This Easter, instead of hunting for chocolate eggs, why not hunt for hidden job opportunities? While children are searching under bushes and behind trees, you can dig through job postings and uncover rare career opportunities using data analysis and automation.
This tutorial will guide you through building an automated job alert system using Python, an API, and email notifications, helping you get special jobs delivered to your inbox every morning without spending hours manually browsing job boards.
Prerequisites
To successfully follow along with this tutorial and build your own automated job search tool, you should have a few essential components ready. These prerequisites will ensure a smooth learning experience and allow you to implement the concepts effectively.
- Make sure you have
Pythoninstalled on your computer for retrieving and processing job data. - A basic familiarity with
JSONand REST APIs is recommended, as the job postings are returned in JSON format. - To receive job alerts via email, you should have an
SMTP-based email provider, such as Gmail or Outlook. - Finally, a text editor or an Integrated Development Environment (
IDE) like VS Code, PyCharm, or even a simple text editor.
This tutorial assumes that you have a basic understanding of Python, including fundamental concepts like loops, conditionals, and working with libraries. However, even if you are new to coding, don't be discouraged—by following along carefully and experimenting with the code, you can still complete the project successfully.
Setting Up API Access
The Daily International Job Postings API provides job postings from the last three months, making it a powerful resource for job seekers. To access the API, follow these steps:
- Sign up for a free account on RapidAPI.
- Subscribe to the Basic plan of the Daily International Job Postings API (which has 25 free requests).
- Retrieve your unique API key from the RapidAPI dashboard.
- Familiarize yourself with the API Documentation
Once you have your API key, you’re ready to start retrieving job postings.
Defining Your Job Search Criteria
To make job hunting efficient, we need to filter job postings based on specific criteria, described in the API Documentation. The API allows us to narrow down search results using parameters such as location, occupation, required skills, and date of posting.
For this tutorial, let's assume you're looking for CTO positions in London (UK).
parameters = {
"dateCreated": "2025-03",
"countryCode": "uk",
"city": "London",
"title": 'CTO,"Chief Technology"'
}
This ensures that only relevant job postings are retrieved, reducing the need to manually sift through hundreds of listings. The more specific your criteria, the more tailored your job alerts will be.
Retrieving Job Postings with Python
With our API key and search criteria ready, let’s fetch job postings using Python’s requests library. The following script sends a request to the API and retrieves job listings:
import requests
from datetime import datetime, timedelta
API_URL = "https://daily-international-job-postings.p.rapidapi.com/api/v2/jobs/search"
HEADERS = {
"x-rapidapi-host": "daily-international-job-postings.p.rapidapi.com",
"x-rapidapi-key": "<YOUR_API_KEY>"
}
# Calculate the date-string "yyyy-MM" for the last month
date_string = (datetime.today().replace(day=1) - timedelta(days=1)).strftime("%Y-%m")
parameters = {
"dateCreated": date_string,
"countryCode": "uk",
"city": "London",
"title": 'CTO,"Chief Technology"',
"page": 1
}
all_jobs = []
page = 1
MAX_PAGES = 2 # cap requests to stay free
total_count = 9999999
while len(all_jobs) < total_count and page <= MAX_PAGES:
parameters["page"] = page
response = requests.get(API_URL, headers=HEADERS, params=parameters)
if response.status_code != 200:
print(f"Error fetching data: {response.status_code}")
break
data = response.json()
jobs = data.get("result", [])
total_count = data.get("totalCount", 0)
if not jobs:
break # Exit loop if no jobs are returned
all_jobs.extend(jobs)
# print(f" Fetched {len(jobs)} jobs from page {page}")
page += 1
print(f"Total jobs retrieved for {date_string}: {len(all_jobs)} of {total_count}")
This script fetches job postings page by page until all available jobs are collected. The totalCount field indicates the total number of jobs available, but we're staying at max. 2 pages for now as we only have 25 free requests.
Formatting Job Postings as an HTML Table
Once we have retrieved all job postings, we can format them as an HTML table for better readability. The following script generates an HTML representation of the job data:
html = """<html>
<head>
<style>
table { width: 100%%; border-collapse: collapse; }
th, td { border: 1px solid black; padding: 8px; text-align: left; }
th { background-color: #f2f2f2; }
</style>
</head>
<body>
<h2>Job Postings</h2>
<table style="width: 100%%; border-collapse: collapse;">
<tr>
<th style="text-align: left;">Title</th>
<th style="text-align: left;">Company</th>
<th style="text-align: left;">City</th>
<th style="text-align: left;">Date Posted</th>
<th style="text-align: left;">Job URL</th>
</tr>
"""
for job in jobs:
title = job.get("title", "N/A")
company = job.get("company", "Unknown")
city = job.get("city", "N/A")
date_created = job.get("dateCreated", "Unknown Date")
url = job['jsonLD']['url']
html += f"""
<tr>
<td>{title}</td>
<td>{company}</td>
<td>{city}</td>
<td>{date_created}</td>
<td><a href="{url}" target="_blank">View Job</a></td>
</tr>
"""
html += """
</table>
</body>
</html>
"""
with open("job_postings.html", "w", encoding="utf-8") as file:
file.write(html)
print("Job postings saved to job_postings.html")
After running the script, an job_postings.html file is created, containing a structured table of all job postings. Open this file in a web browser to explore the listings in a readable format.
Sending Job Alerts via Email
To ensure that you receive job updates without manually running the script, we will automate email notifications. The following Python script uses the formated job postings and sends them via email:
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
SMTP_SERVER = "smtp.gmail.com"
SMTP_FROM = "your-email@gmail.com"
SMTP_PASS = "your-password"
EMAIL_TO = "recipient@example.com"
EMAIL_SUBJECT = "New Job Postings Found!"
# Create an email message
msg = MIMEMultipart()
msg['From'] = SMTP_FROM
msg['To'] = EMAIL_TO
msg['Subject'] = EMAIL_SUBJECT
# Attach the HTML table as the email body
msg.attach(MIMEText(html, "html"))
# Send the email
with smtplib.SMTP_SSL(SMTP_SERVER) as server:
server.login(SMTP_FROM, SMTP_PASS)
server.sendmail(SMTP_FROM, EMAIL_TO, msg.as_string())
print("Email notification sent successfully!")
This script uses the HTML-formatted job listings in an email and sends it using an SMTP server (e.g., Gmail). You can replace the credentials with your email provider’s details. For security, consider using environment variables or a configuration file instead of hardcoding credentials.
Automating the Job Search Process
To ensure that job alerts are sent regularly, we can automate this script using a cron job (Linux/macOS) or Task Scheduler (Windows). For example, the following cron job runs the script daily at 17:00 (5 PM):
0 17 * * * /usr/bin/python3 /path/to/your_script.py
This way, you’ll receive job alerts without any manual intervention, ensuring that you never miss out on potential opportunities.
Conclusion
By combining data analysis, automation, and job search techniques, this project allows you to discover hidden job opportunities tailored to your skills and preferences. Instead of endlessly searching and scrolling through job listings, let Python do the work for you.
So, while others are hunting for Easter eggs this season, take on this fun and rewarding challenge to uncover hidden jobs that could lead to your next great career opportunity.
Happy job hunting!