Workable APIjobs.workable.com ↗
Extract job application form fields and screening questions from Workable job listings. Returns sections, field types, labels, and job metadata.
What is the Workable API?
The Workable Jobs API exposes 1 endpoint — get_application_questions — that returns the complete application form for any Workable job listing. Each response includes up to three form sections (personal information, profile, and details), with field-level metadata such as label, type, and whether the field is required. Custom screening questions with their answer options are returned under the Details section alongside basic job metadata like title, company, location, and workplace type.
curl -X GET 'https://api.parse.bot/scraper/2265f04c-f636-4651-98dd-bf4d6940e982/get_application_questions?job_id=7M5Gmwmb8M1xi1EKDdQqhE' \ -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 jobs-workable-com-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: Workable job application questions — fetch and inspect a form."""
from parse_apis.jobs_workable_com_api import Workable, JobNotFound
client = Workable()
# Fetch the application form for a known job listing.
try:
form = client.application_forms.get(job_id="<job_id_from_url>")
except JobNotFound:
print("Job listing not found or no longer available.")
raise
print(f"{form.job_title} at {form.company}")
print(f"Location: {form.location} | Type: {form.employment_type} | Workplace: {form.workplace}")
# Walk each section and its fields.
for section in form.sections:
print(f"\n--- {section.section_name} ---")
for field in section.fields:
required_tag = "*" if field.required else ""
print(f" [{field.type}] {field.label}{required_tag} (id={field.id})")
# Show dropdown/radio options when present.
if field.options:
for opt in field.options:
print(f" - {opt.name} ({opt.value})")
print("\nexercised: application_forms.get")
Retrieves the application form for a Workable job listing, including all sections (personal information, profile, details) and their fields. Custom screening questions with options are included in the Details section. Also returns basic job metadata (title, company, location). One API call fetches the form; a second fetches job metadata. Returns an empty sections array if the job has no form fields.
| Param | Type | Description |
|---|---|---|
| job_idrequired | string | Workable job identifier from the URL path, e.g. '7M5Gmwmb8M1xi1EKDdQqhE' from jobs.workable.com/view/7M5Gmwmb8M1xi1EKDdQqhE/... |
{
"type": "object",
"fields": {
"job_id": "string — the Workable job identifier",
"company": "string — hiring company name",
"location": "string — job location country",
"sections": "array of form sections, each with section_name and fields array containing field objects with id, label, type, required, and optional properties like options, helper, max_length, max_value, single_option, supported_file_types, max_file_size",
"job_title": "string — job posting title",
"workplace": "string — e.g. remote, onsite, hybrid",
"employment_type": "string — e.g. Full-time, Part-time"
},
"sample": {
"data": {
"job_id": "7M5Gmwmb8M1xi1EKDdQqhE",
"company": "Hyprwork",
"location": "Spain",
"sections": [
{
"fields": [
{
"id": "firstname",
"type": "text",
"label": "First name",
"required": true,
"max_length": 127
},
{
"id": "email",
"type": "email",
"label": "Email",
"required": true,
"max_length": 255
}
],
"section_name": "Personal information"
},
{
"fields": [
{
"id": "QA_12364301",
"type": "multiple",
"label": "Where did most of your work happen over the last three years?",
"options": [
{
"name": "6435011",
"value": "a) Cloud infrastructure, deployment pipelines and system reliability"
},
{
"name": "6435012",
"value": "b) Product engineering delivery for a software company"
}
],
"required": true,
"single_option": false
}
],
"section_name": "Details"
}
],
"job_title": "Head of Web Production (DTC Growth Technology)",
"workplace": "remote",
"employment_type": "Full-time"
},
"status": "success"
}
}About the Workable API
What the API Returns
The get_application_questions endpoint accepts a single required parameter: job_id, the alphanumeric identifier found in the Workable job URL (e.g., 7M5Gmwmb8M1xi1EKDdQqhE from jobs.workable.com/view/7M5Gmwmb8M1xi1EKDdQqhE). The response includes top-level job metadata: job_title, company, location (country), workplace (remote, onsite, or hybrid), and employment_type (e.g., Full-time, Part-time).
Form Sections and Fields
The sections array breaks the application form into named sections — typically Personal Information, Profile, and Details. Each section contains a fields array where every field object carries an id, label, type, and required flag. The Details section is where employer-configured screening questions appear, and for multiple-choice or dropdown fields the options array lists each selectable value.
Coverage and Use
This API covers any publicly accessible Workable job listing. Because the job_id is the only input, you can integrate it into any pipeline that already collects Workable job URLs — ATS research tools, application automation frameworks, or job board aggregators that need to understand what information a specific employer requires before a candidate applies.
The Workable API is a managed, monitored endpoint for jobs.workable.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when jobs.workable.com 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 jobs.workable.com 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?+
- Pre-fill or validate application form inputs for a candidate-facing job application tool by reading each field's label, type, and required status.
- Audit which employers on Workable include specific screening question types (e.g., dropdowns vs. free-text) across a set of job listings.
- Build a comparison matrix of required vs. optional fields across multiple job postings at the same company.
- Detect custom screening questions and their options to prepare candidates with relevant answers before they open the application.
- Map Workable application form structure to an internal ATS schema by reading the sections and field IDs programmatically.
- Filter job listings by workplace type (remote, hybrid, onsite) and employment type using the top-level metadata fields.
| 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.
Does Workable have an official developer API?+
What does the `sections` field actually contain?+
sections array contains one object per form section on the application page. Each section has a section_name string and a fields array. Each field object includes id, label, type (e.g., text, dropdown, checkbox), required (boolean), and — for choice-type fields — an options array listing the selectable values. Employer-defined screening questions appear in the Details section.Can I retrieve a list of all open jobs at a company without already knowing the job IDs?+
job_id. It does not include an endpoint for searching or listing jobs by company name or keyword. You can fork this API on Parse and revise it to add a job-search or company-listing endpoint.Does the API return the full job description or requirements text?+
job_title, company, location, workplace, and employment_type, but not the freeform job description body or requirements section. You can fork this API on Parse and revise it to add a field that returns the full job description content.