Breezy APIvald.breezy.hr ↗
Retrieve published job openings and full application form fields from any Breezy HR careers site. Two endpoints: list positions and get form structure.
What is the Breezy API?
This API exposes two endpoints for reading any public Breezy HR careers site: list_positions returns every published opening with position IDs, titles, employment types, departments, and locations in a single call, while get_application_form returns the complete application form structure for a specific listing — including all field settings across three sections and any screening questionnaire attached to that role.
curl -X GET 'https://api.parse.bot/scraper/0c2ecd13-1cd6-4466-abc4-d9e2dfa7e601/list_positions?company=vald' \ -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 vald-breezy-hr-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.
"""Walkthrough: Breezy HR Careers API — list openings, inspect an application form."""
from parse_apis.vald_breezy_hr_api import BreezyHR, PositionNotFound
client = BreezyHR()
# List published positions for a company, capped at 5.
for pos in client.positions.list(company="vald", limit=5):
print(pos.title, "|", pos.location, "|", pos.employment_type)
# Drill into the first position's full application form.
position = client.positions.list(company="vald", limit=1).first()
if position is not None:
try:
form = client.application_forms.get(
company="vald", position_id=position.position_id
)
except PositionNotFound:
print("Position was unpublished before we could fetch the form.")
else:
print(form.title, "—", form.location)
print("Apply:", form.apply_url)
# Walk the standard form sections and their fields.
for section in form.sections:
print(f"\n[{section.title}]")
for field in section.fields:
req = "required" if field.required else "optional"
print(f" {field.label} ({field.type}, {req})")
# Show field-level visibility settings.
fs = form.field_settings
print("\nResume:", fs.resume, "| Cover letter:", fs.cover_letter)
# Screening questionnaire (if any).
for qs in form.questionnaire_sections:
for q in qs.questions:
opts = ", ".join(q.options) if q.options else "free-text"
print(f" Q: {q.text} [{opts}]")
print("exercised: positions.list / application_forms.get")
Lists every published job opening on a company's Breezy HR careers site in one round trip (no pagination; the site returns the whole list). Each item is one position with its position_id, title, employment type, department, location and publish date. An empty positions array means the company currently has no published openings. Invalid subdomain format yields an input error; an unknown company yields the site's error status.
| Param | Type | Description |
|---|---|---|
| companyrequired | string | The company's Breezy careers-site subdomain, i.e. the <company> part of <company>.breezy.hr (lowercase letters, digits, hyphens). |
{
"type": "object",
"fields": {
"total": "integer count of positions returned",
"company": "echo of the careers-site subdomain queried",
"positions": "array of published openings, each with position_id (12-char hex id usable with get_application_form), title, url (public listing page), published_date (ISO 8601), employment_type, department, location (display name), country, is_remote (boolean), salary (display string, may be empty)"
},
"sample": {
"data": {
"total": 61,
"company": "vald",
"positions": [
{
"url": "https://vald.breezy.hr/p/4d1d01de90ac-business-development-manager",
"title": "Business Development Manager",
"salary": "",
"country": "Canada",
"location": "Canada",
"is_remote": false,
"department": "Commercial",
"position_id": "4d1d01de90ac",
"published_date": "2026-08-05T10:16:06.708Z",
"employment_type": "Full-Time"
}
]
},
"status": "success"
}
}About the Breezy API
What the API Covers
The API targets public Breezy HR careers subdomains (the <company>.breezy.hr pattern). Pass any company subdomain to list_positions and receive the full set of active openings in one round trip. Each entry in the positions array includes a position_id (a 12-character hex string), title, employment_type, department, location, and url pointing to the public listing page. The total field gives the count of positions returned, and an empty array means no published openings were found.
Application Form Detail
get_application_form takes a company subdomain and a position_id from the listing step. It returns the form broken into three sections keyed as personal_information, profile, and details. Each section contains a fields array where every field carries its name, label, and configured state. The field_settings object maps every standard field name to one of three values — required, optional, or hidden — so you can programmatically detect exactly what a given employer requires from applicants. Fields the employer has disabled surface in the hidden_fields array as well.
Screening Questionnaires
Beyond the standard form sections, get_application_form includes any screening questionnaire the employer attached to that specific position. Questionnaire items are returned alongside the standard sections, letting you capture the full set of questions a candidate would encounter before submitting.
Scope and Identifiers
Both endpoints are scoped to a single company at a time — there is no cross-company search. The position_id value returned by list_positions feeds directly into get_application_form, making the two endpoints a natural two-step workflow for any pipeline that needs to enumerate openings and then inspect each form.
The Breezy API is a managed, monitored endpoint for vald.breezy.hr — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when vald.breezy.hr 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 vald.breezy.hr 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?+
- Track new job openings posted to a specific company's Breezy HR careers page using list_positions
- Compare application form field requirements across multiple employers using field_settings from get_application_form
- Identify which roles include salary fields or desired-location fields for compensation research
- Build a job-alert system that monitors position count changes on a target company's careers site
- Audit hidden_fields across positions to understand what data a particular employer collects from candidates
- Extract department and employment_type breakdowns from a company's active openings for competitive talent analysis
- Pre-fill or validate application workflows by reading the exact required/optional/hidden state of every form field
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.