Article type: How-to guide (one task: export every open job from one Workday career site to a CSV, including boards with more than 2,000 jobs)
Prerequisites: Python 3.12 or later with
requests(pip install requests). No API key or account: the script reads the same public job search the career site's own page uses. An Apify account only if you use the hosted version at the end.Tested on: 15 November 2026, against two live career sites on
myworkdayjobs.com.
Lots of large employers run their careers page on Workday, at an address like https://{company}.wd5.myworkdayjobs.com/{site}. If you want those jobs in a spreadsheet, say to track who's hiring for what, the page has no download button. But the careers page itself loads its job list from a JSON endpoint with no login, and you can call that endpoint from Python. This guide does that, checks the site's robots.txt first, and works around the limit that stops a plain loop at 2,000 jobs.
The job lists and counts in this post come from one endpoint on each career site:
POST https://{company}.wd{N}.myworkdayjobs.com/wday/cxs/{company}/{site}/jobs
with a JSON body like {"appliedFacets": {}, "limit": 20, "offset": 0, "searchText": ""}. It returns up to 20 jobs (title, location text, a "Posted ..." label, a requisition ID and the job's path), a total, and facets: the filters the page shows, such as country, state or job area, each with a job count. Treat it as the page's own internal endpoint: read gently and expect it to change.
How do I export all jobs from a Workday career site?
Give the script the career-site address. It reads robots.txt, pages the job search 20 at a time, and if the board has 2,000 or more jobs it splits the search by one of the site's own filters (and splits again if a part is still too big), merging the results by job path. Save it as workday_jobs.py:
import csv
import re
import sys
import time
from collections import Counter
from datetime import date, timedelta
from urllib.parse import urlparse
from urllib.robotparser import RobotFileParser
import requests
SITE_URL = sys.argv[1] if len(sys.argv) > 1 else "https://astrazeneca.wd3.myworkdayjobs.com/Careers"
UA = "workday-jobs-csv-tutorial/1.0 (python-requests)"
PAGE = 20 # the most Workday accepts per request
CAP = 2000 # the most results one search can reach
GAP = 0.4 # seconds between requests: one at a time, gently
u = urlparse(SITE_URL)
tenant = u.hostname.split(".")[0]
site = [p for p in u.path.split("/") if p and not re.fullmatch(r"[a-z]{2}-[A-Z]{2}", p)][0]
api = f"{u.scheme}://{u.hostname}/wday/cxs/{tenant}/{site}/jobs"
# 1. Read robots.txt first, and stop if it can't be read or disallows the job search.
r = requests.get(f"{u.scheme}://{u.hostname}/robots.txt", headers={"User-Agent": UA}, timeout=30)
if r.status_code != 200 or r.text.lstrip().startswith(("{", "<")):
sys.exit(f"robots.txt answered HTTP {r.status_code}; not reading this site")
robots = RobotFileParser()
robots.parse(r.text.splitlines())
if not robots.can_fetch(UA, f"/wday/cxs/{tenant}/{site}/jobs"):
sys.exit("robots.txt disallows the job search")
session = requests.Session()
session.headers.update({"User-Agent": UA, "Accept": "application/json"})
calls = 0
def search(applied, offset=0):
global calls
time.sleep(GAP)
calls += 1
r = session.post(api, json={"appliedFacets": applied, "limit": PAGE, "offset": offset, "searchText": ""}, timeout=60)
r.raise_for_status()
return r.json()
def facets(data):
"""Top-level facets with a count per value, e.g. jobFamilyGroup -> [(id, label, count), ...]."""
out = {}
for f in data.get("facets", []):
vals = f.get("values", [])
if vals and all("count" in v for v in vals):
out[f["facetParameter"]] = [(v["id"], v["descriptor"], v["count"]) for v in vals]
return out
jobs = {}
def page_all(applied, first):
"""Page one search (it must have fewer than 2,000 results)."""
data, offset = first, 0
while True:
for p in data["jobPostings"]:
jobs.setdefault(p.get("externalPath") or p.get("title"), p)
offset += PAGE
if len(data["jobPostings"]) < PAGE or offset >= CAP:
return
data = search(applied, offset)
def collect(applied, count, first, where="whole board"):
"""Read every job in a search; split it by a filter when it holds 2,000 or more."""
if count < CAP:
return page_all(applied, first)
options = {k: v for k, v in facets(first).items() if k not in applied and sum(c for *_, c in v) >= count}
if not options:
print(f" can't split {where} further; reading its first {CAP}")
return page_all(applied, first)
param = min(options, key=lambda k: max(c for *_, c in options[k])) # the most even split
print(f" {where}: {count} jobs, split by {param} ({len(options[param])} values)")
for vid, label, c in options[param]:
sub = {**applied, param: [vid]}
collect(sub, c, search(sub), label if where == "whole board" else f"{where} > {label}")
first = search({})
sums = Counter(sum(c for *_, c in v) for v in facets(first).values())
true_total = max(sums, key=lambda s: (sums[s], -s)) # most filters add up to the same number: the real total
print(f"{tenant}/{site}: first page says total={first['total']}, filter counts add up to {true_total}")
collect({}, true_total if first["total"] >= CAP else first["total"], first)
def posted(text):
"""'Posted Today' / 'Posted Yesterday' / 'Posted 3 Days Ago' / 'Posted 30+ Days Ago' -> an approximate date."""
t = (text or "").lower()
if "today" in t:
return date.today().isoformat(), "approx"
if "yesterday" in t:
return (date.today() - timedelta(days=1)).isoformat(), "approx"
m = re.search(r"(\d+)(\+?) days", t)
if m:
d = (date.today() - timedelta(days=int(m.group(1)))).isoformat()
return d, "on or before" if m.group(2) else "approx"
return "", ""
rows = []
for path, p in jobs.items():
if not p.get("title"):
continue # skip any posting without a title
when, basis = posted(p.get("postedOn"))
rows.append({
"job_id": (p.get("bulletFields") or [""])[0],
"title": p["title"],
"location": p.get("locationsText", ""),
"posted_on_text": p.get("postedOn", ""),
"posted_date": when,
"posted_date_basis": basis,
"url": f"{u.scheme}://{u.hostname}/{site}{path}",
})
out = f"workday_jobs_{tenant}.csv"
with open(out, "w", newline="") as f:
w = csv.DictWriter(f, fieldnames=list(rows[0]))
w.writeheader()
w.writerows(rows)
print(f"{calls} requests; {len(jobs)} postings read of {true_total} open, {len(rows)} with a title; wrote {out}")
print(f" {len({r['job_id'] for r in rows})} distinct job IDs")
print(f" {sum(bool(re.fullmatch(r'\d+ Locations', r['location'])) for r in rows)} say 'N Locations' instead of a place")
for text, n in Counter(r["posted_on_text"] for r in rows).most_common(6):
print(f" {text:<22}{n:>6}")
Output on 15 November 2026 for AstraZeneca's career site (the default URL), which has fewer than 2,000 jobs:
astrazeneca/Careers: first page says total=1410, filter counts add up to 1410
71 requests; 1410 postings read of 1410 open, 1410 with a title; wrote workday_jobs_astrazeneca.csv
1410 distinct job IDs
121 say 'N Locations' instead of a place
Posted 30+ Days Ago 306
Posted 19 Days Ago 130
Posted 9 Days Ago 129
Posted 4 Days Ago 71
Posted 10 Days Ago 71
Posted 3 Days Ago 68
And for Target's career site, which has more than 2,000 (python workday_jobs.py https://target.wd5.myworkdayjobs.com/targetcareers). This run used the first version of the script, which didn't yet print the "split by" lines; the logic was the same:
target/targetcareers: first page says total=2000, filter counts add up to 14122
882 requests; 14111 postings read, 14111 with a title; wrote workday_jobs_target.csv
14111 distinct job IDs
75 say 'N Locations' instead of a place
Posted 30+ Days Ago 12852
Posted 17 Days Ago 168
Posted 2 Days Ago 80
Posted 5 Days Ago 76
Posted Yesterday 65
Posted 12 Days Ago 64
Some rows from workday_jobs_astrazeneca.csv (URL column left out):
job_id,title,location,posted_on_text,posted_date,posted_date_basis
R-264347,Sr. Talent Acquisition Partner - Early Talent,US - Gaithersburg - MD,Posted Yesterday,2026-11-14,approx
R-263984,"Senior Director, Franchise Strategy, Cell Therapy",US - Gaithersburg - MD,Posted Yesterday,2026-11-14,approx
R-263198,"Director, Portfolio Management",US - Gaithersburg - MD,Posted Yesterday,2026-11-14,approx
R-261871,"Pharmaceutical Sales Specialist - CVRM Primary Care - Langhorne, PA",US - Langhorne - PA,Posted 30+ Days Ago,2026-10-16,on or before
R-263636,Medical Science Liaison - (Hematology) - N TX/CO/NM,4 Locations,Posted Yesterday,2026-11-14,approx
Why it's built this way:
-
robots.txtfirst. The script stops if the file can't be read or disallows the job search. It reads it with a plain request, before the session adds a JSONAcceptheader (see gotcha 6). - One request at a time, with a pause. The Target export took 882 requests. With a 0.4-second gap plus the site's own response time, that took 32 minutes. Don't run several in parallel against one site.
-
Merge by the job's path. Splitting by state puts a job listed in two states into both parts, so jobs are stored in a dict keyed on
externalPathand each is kept once. -
The real total comes from the filter counts. Above 2,000,
totalstops being the real count (gotcha 2), so the script takes the number most of the site's filters add up to and compares what it read against that.
What should I check before I trust the export?
-
20 jobs per request, no more. On AstraZeneca's site
limit: 20returned HTTP 200;limit: 21andlimit: 50both returned HTTP 400. -
One search stops at 2,000, without an error. On Target's site the first page said
total: 2000while its filters added up to 14,122 jobs. Pages after the first saidtotal: 0, and offset 2,000 (and 3,000) returned the same 20 jobs as offset 0. A loop that pages until it stops getting new jobs ends at 2,000 and looks finished. - Not every filter count is the real total. On Target's first page, country, job area, job type and schedule each added up to 14,122. States added up to 14,145, because some jobs are listed in more than one state, and the one remote-type value covered only 20 jobs. Take the number most filters agree on.
- One split isn't always enough. The script split Target's board by state (52 values), which left California at 2,114 jobs, still over the limit, so it split California again by job type (we saw those two lines in a later run of the final script). The export read 14,111 of the 14,122 jobs the filters counted, 11 short. Jobs open and close during a half-hour read, and a job with no value for the filter you split on can't be reached through that split, so compare the two numbers on every run rather than assuming you got everything.
-
Posted dates are labels, not dates. The listing only says "Posted Today", "Posted Yesterday", "Posted 9 Days Ago" or "Posted 30+ Days Ago". 306 of AstraZeneca's 1,410 jobs and 12,852 of Target's 14,111 said "30+ Days Ago". The script turns the label into an approximate date and marks 30+ as "on or before". The job's own page (
GET /wday/cxs/{company}/{site}{externalPath}) has the real date: one AstraZeneca job listed as "30+ Days Ago" had astartDateof 2026-10-14. That's one extra request per job. -
A JSON
Acceptheader breaksrobots.txt. When we sentAccept: application/jsontorobots.txton 22 Workday career-site hosts, all 22 answered HTTP 406. With a plain request, 16 returned arobots.txtfile and 6 answered HTTP 422. The script stops on anything but a clean file. - "4 Locations" isn't a place. 121 of AstraZeneca's 1,410 jobs had a location like "4 Locations" in the listing. The job's page lists them: for one, a main location plus 3 more.
- Big reads can stall. A second full read of Target's board, started right after the first, failed after about 25 minutes when one request got no answer within the script's 60-second timeout. For boards this size, retry a failed page a few times with a growing pause, or stop and try later, rather than starting over at full speed.
-
Fields vary by site, and none is pay. AstraZeneca's listing had six fields per job (title, path, time type, location text, posted label, requisition ID), and none of them was pay. Other sites can return a different set, so read fields with
.get().
To use another site, pass its career-site address (the part before /job/... when you open a job). For a company that lists jobs on more than one Workday site, the Sitemap: lines in robots.txt name each site.
The hosted version (Disclosure: we built this)
We built an Apify Actor, Careers Page Scraper: Greenhouse Jobs, Lever & Workday Jobs, that reads the same public job search live on every run. Give it a myworkdayjobs.com link, a workday: token, a company name or a domain. On boards with more than 2,000 jobs it splits the search by job family (and by other filters the site offers when needed), merges by job ID, takes the true total from Workday's filter counts, and if some jobs can't be read the company's note says how many and why. It goes one request at a time per site with a short gap, backs off on HTTP 429, and respects robots.txt: a host whose robots.txt can't be read cleanly is skipped with a free error row. Rows have department from the job family when the site has one, and postedAt from the "Posted ..." label for jobs from the last 30 days, marked approximate-from-listing-text; "30+ Days Ago" jobs have no postedAt unless their page is read. Multi-location jobs show "N Locations" (for example "4 Locations") unless you set a locations filter or remoteOnly, which reads each job's page. Workday rows have no salary. Title, location, remote and posted-date filters run before anything is returned or charged, every job row carries companyTotalJobs, and it reads Greenhouse, Lever, Ashby and eight other systems in the same run. It's pay per event, charged per job returned, per company whose board is found and read, and per run start; the prices are on the Actor's Pricing tab. For example (not run for this post):
{
"companies": ["https://astrazeneca.wd3.myworkdayjobs.com/Careers", "https://target.wd5.myworkdayjobs.com/targetcareers"],
"maxJobsPerCompany": 0
}
Data: each employer's public Workday career site, read 15 November 2026. Jobs are as posted by the employers. This post and the Actor are not affiliated with or endorsed by Workday or any employer named.
Your Evenings
Top comments (0)