Ca APIcaljobs.ca.gov ↗
Search California job postings and retrieve full job details from CalJOBS via 2 endpoints. Returns title, salary, location, schedule, and HTML job descriptions.
What is the Ca API?
The CalJOBS API provides access to California's official state job board through 2 endpoints: search_jobs and get_job_details. A single search returns up to 100 job postings per call, each including company name, position title, salary, location, posting date, job type, schedule, and occupation. The get_job_details endpoint retrieves the full job description and employer information for any listing by its job order ID.
curl -X GET 'https://api.parse.bot/scraper/adff110d-b9a7-4428-8a8b-8fc21eeac3cd/search_jobs?keyword=software+engineer' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace caljobs-ca-gov-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""CalJOBS API — search California job postings and drill into details."""
from parse_apis.caljobs_api import CalJobs, JobNotFound
client = CalJobs()
# Search for nursing jobs — limit caps total items fetched.
for job in client.jobsummaries.search(keyword="registered nurse", limit=5):
print(job.position, "|", job.company, "|", job.location, "|", job.salary)
# Drill into the first result for the full description.
first = client.jobsummaries.search(keyword="data scientist", limit=1).first()
if first:
detail = first.details()
print(detail.title, "|", detail.company)
print(detail.html_summary[:200])
# Direct lookup by job_id when you already have one.
try:
full = client.jobs.get(job_id="8967206")
print(full.title, full.company)
except JobNotFound as exc:
print(f"Job {exc.job_id} is no longer listed")
print("exercised: jobsummaries.search / JobSummary.details / jobs.get / JobNotFound catch")
Search for job postings by keyword on CalJOBS. Returns up to 100 results per search with job metadata including company, position, salary, location, and posting date. Results are ordered by relevance. The geo filter is fixed to California.
| Param | Type | Description |
|---|---|---|
| keyword | string | Search keyword such as job title, company name, or occupation. |
{
"type": "object",
"fields": {
"jobs": "array of job objects with company, position, salary, location, date_posted, job_id, source, occupation, job_type, schedule",
"total_results": "integer total number of matching jobs",
"results_returned": "integer number of jobs returned in this response (max 100)"
},
"sample": {
"data": {
"jobs": [
{
"job_id": "8967206",
"salary": "Salary Not Available",
"source": "Private Job Board",
"company": "Northrop Grumman Corporation",
"job_type": "Regular",
"location": "Redondo Beach, CA",
"position": "2027 Associate Software Engineer/Software Engineer",
"schedule": "Schedule - Full Time",
"occupation": "Computer Systems Engineers/Architects",
"date_posted": "2026-06-10"
}
],
"total_results": 10000,
"results_returned": 3
},
"status": "success"
}
}About the Ca API
Endpoints
The search_jobs endpoint accepts a keyword string — a job title, company name, or occupation term — and returns a ranked list of up to 100 matching postings from CalJOBS. Each result object includes company, position, salary, location, date_posted, job_id, source, occupation, job_type, and schedule. The response also includes total_results (the full count of matches in the database) and results_returned (the count actually delivered, capped at 100).
Job Details
Once you have a job_id from search_jobs, pass it to get_job_details to retrieve the complete posting. The response contains title, job_id, company, and html_summary — an HTML string representing the full job description section, which typically includes duties, requirements, and application instructions as authored by the employer.
Data Source and Coverage
All data comes from caljobs.ca.gov, California's official workforce development portal operated by the California Employment Development Department (EDD). Listings span public and private sector employers across all California counties. Coverage is limited to jobs posted to CalJOBS; positions posted exclusively on private job boards or employer career pages do not appear.
Pagination and Filtering
The search_jobs endpoint returns a maximum of 100 results per call and does not expose pagination parameters or server-side filtering beyond the keyword field. If total_results exceeds 100, narrowing the keyword to a more specific title or occupation is the practical way to surface relevant listings within the response cap.
The Ca API is a managed, monitored endpoint for caljobs.ca.gov — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when caljobs.ca.gov changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official caljobs.ca.gov API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Aggregate California state and local government job openings by occupation for a public-sector job board.
- Monitor new postings for a specific company name using the
keywordparameter insearch_jobs. - Extract salary ranges from job results to build compensation benchmarks for California roles.
- Pull
html_summaryfromget_job_detailsto index full job descriptions for semantic search. - Track
date_postedandjob_typefields to analyze hiring trends across California regions. - Feed CalJOBS listings into an SMS or email alert system filtered by
locationorschedule.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does CalJOBS have an official developer API?+
What does the `search_jobs` endpoint return and how many results can I get per call?+
company, position, salary, location, date_posted, job_id, occupation, job_type, and schedule — plus total_results and results_returned. The hard cap per call is 100 results. If your target set is larger, refining the keyword to a narrower title or occupation is the way to improve relevance within that limit.Can I filter search results by location, date posted, or job type?+
search_jobs endpoint accepts only a keyword parameter; server-side filtering by location, date range, salary, or job type is not exposed. The location, date_posted, and job_type fields are available in each result object, so client-side filtering is possible after retrieval. You can fork this API on Parse and revise it to add those filter parameters as inputs.Does the API cover job postings outside California?+
Is there a pagination mechanism to retrieve more than 100 results from a single search?+
search_jobs endpoint does not expose pagination parameters — each call returns at most 100 results. total_results tells you how many total matches exist, but there is no built-in offset or page cursor. You can fork this API on Parse and revise it to add pagination support for deeper result retrieval.