Workable Integration Guide
Overview
The Jack & Jill integration with Workable keeps your ATS in step as candidates move through your recruiting pipeline. When you take actions in Jack & Jill — such as saving a candidate or requesting an introduction — those changes are reflected in Workable. Jack & Jill also reads back what happens to the candidates it sent, so a hire or a rejection made in Workable shows up in your pipeline.
What it does
- Creates candidates in Workable when an enabled lifecycle event fires, including their resume
- Moves candidates through your Workable pipeline stages as they progress
- Disqualifies candidates when you pass on a lead Jill added
- Deduplicates automatically — if the candidate is already on the Workable job (matched by email), the integration links to them rather than creating a duplicate
- Attributes changes to a Workable member of your choice, and optionally to a source name, so your team can see where candidates came from
Prerequisites
- A Workable account with Admin access (needed to create API tokens)
- A Jack & Jill account with at least one active role
- A Workable job that is published or used internally for each role you want to link
Getting started
1. Create a Workable API token
In Workable, open your profile menu, then Settings → Integrations → Apps. Under API Access Tokens, choose + Generate API token. Give it a name and choose an expiry. Tokens stop working at their expiry, so pick a long one and note the date.
Select these scopes:
| Scope | Why it’s needed |
|---|---|
r_jobs |
List the jobs you can link roles to, and read their pipelines |
r_candidates |
Check whether a candidate is already on the job, and read their stage |
w_candidates |
Create candidates, move them between stages and disqualify them |
Copy the token straight away — Workable only shows it once. If you later see candidates arrive without their resume, check the token’s write access to candidates first.
2. Connect the integration
Navigate to Integrations → Workable, paste the token, and enter your account subdomain. The subdomain is the part before .workable.com in your Workable address (for example acme for acme.workable.com), not the full URL. Jack & Jill tests the connection.
The test checks that your token can read from Workable. It cannot safely test writing without changing your data, so a missing w_candidates scope is only discovered the first time a change is sent. If a change is refused, the error says whether the token or the acting member is the likely cause.
3. Choose who changes are attributed to
Pick the Workable member that Jack & Jill acts as. Workable requires a member for every candidate change, and shows them in the candidate’s activity. Choose a member with the Admin role: the list shows admins first, and members with limited access are labelled, because a limited member is refused when the job isn’t theirs.
You can also set an optional candidate source name so candidates sent by Jack & Jill are easy to find in Workable.
4. Configure lifecycle events
You choose which pipeline actions automatically sync to Workable:
| Event | What it does in Workable |
|---|---|
| Shortlist | Creates the candidate as sourced on the job |
| Request intro | Moves a candidate who is still at the start of the pipeline to the first review stage (such as Phone Screen) |
| Complete intro | Moves a candidate who is still at the start of the pipeline to the first interview stage |
| Archive | Disqualifies a lead that Jill added |
| Hire | Moves the candidate to Hired |
Request intro and Complete intro never move a candidate backwards, and they only move candidates still at the start of your pipeline (Sourced or Applied). A candidate that Request intro has already moved to a review stage isn’t moved again by Complete intro. Hire is different: it moves a candidate to Hired from any earlier stage. Archive applies to leads Jill added, not to candidates your team has already progressed.
5. Link a role to a Workable job
Open a role’s Configure Role → Integrations → Workable section and select the matching Workable job. Once linked, future lifecycle events for that role sync automatically.
Only jobs that can take candidates are listed:
- Published jobs
- Jobs used internally or confidentially (Workable’s API reports these as closed)
Draft and archived jobs aren’t listed, because Workable refuses new candidates on them. If you archive a job later, changes to its candidates are refused with an explanation rather than retried forever.
What happens when you first link a job: Jack & Jill checks in the background whether any of your existing candidates are already on that Workable job. This takes a minute or two and runs in the background, so refresh the page after a short wait.
How syncing works
When a lifecycle event fires (for example you save a candidate), the integration:
- Checks whether the candidate is already on the linked Workable job, by email
- If not, creates them with their name, email, phone and LinkedIn profile, and uploads their resume
- Moves them to the stage the event calls for
A few things are worth knowing:
- A candidate belongs to one job. If the same person is on two Workable jobs, they appear as two candidates, one per job.
- Workable can take a few seconds to show a new candidate. Changes sent straight after a create are retried automatically until the candidate is visible, so you may see the resume or a stage move arrive a short while after the candidate.
- A LinkedIn link Workable can’t read is dropped, not the candidate: the candidate is still created without the profile link.
- Changes made in Workable are read back. Jack & Jill periodically reads the candidates it sent, so a hire or a disqualification made in Workable is reflected in your pipeline.
Managing the integration
After setup, visit Integrations → Workable to:
- Toggle lifecycle events on or off
- Change the member changes are attributed to, or the candidate source
- Link or unlink roles as you create new ones
- Test the connection to confirm your token still works
- Disconnect the integration (you can reconnect at any time without losing anything in Workable)
FAQ
Will this create duplicate candidates in Workable? No. It looks for the candidate on the job by email first, and only creates one when there is no match.
The connection test passes but changes fail — why? The test only checks read access. Check that the token has the w_candidates scope and that the member you chose is an admin, then try again.
Why isn’t my job in the list? Only published jobs and jobs used internally appear. Publish a draft job or restore an archived one, then refresh.
My token expired. Create a new token with the same scopes and paste it into Integrations → Workable. Nothing is lost in Workable.
Why wasn’t a candidate moved when they accepted an intro? Complete intro only moves candidates still at the start of the pipeline. If Request intro already moved them to a review stage, they stay where they are.
Does disconnecting delete anything in Workable? No. Your Workable data is unaffected, and previously synced candidates remain.
For more questions, see the FAQs page.