null if member has not provided a disqualification reason

The date the candidate was moved to the hired stage

Recruiter keys can be retrieved from the jobs/:shortcode/recruiters endpoint.

the candidate’s resume encoded in base64

Last timestamp when candidate was updated

Candidates

Indicates whether the department has been archived or not.

The department identifier. Note that this id should be used when creating or updating an employee using the POST and PATCH endpoints respectively.

The department identifier of the parent department or null if it is a top level department.

Departments

Employees

A collection with the ancestor departments of the job department including that

Location of the job. When advertise elsewhere is used it contains the advertise location. When advertise elsewhere is not used, it contains the primary location of the job as defined in the job editor.

The country name as defined in job editor

The location string translated into the language of the job

Indicates if this is a remote/telecommute job

The workplace type. Possible values are on_site, hybrid, remote.

The job state. Possible values are draft, published, closed, archived.

Jobs

The member's HRIS role. Possible values are hris_admin and hris_employee

The member's role. Possible values are admin, simple and reviewer

Members

The state of the offer ('accepted', 'rejected', etc.)

Offers

Recruiters

The ID of the candidate. Only exists for filled and reserved requisitions.

The employment type. Can be one of Full-time, Part-time, Contract, Temporary, Other.

The string representation of the location

The plan date of the requisition in YYYY-MM-DD format

The reason for the requisition. Can be one of new_hire, replacement, backfill.

The 3-letter ISO code of the currency (ie EUR, USD).

The frequency of the salary. Can be one of hour, day, week, month, year.

The frequency of the salary range. Can be one of hour, day, week, month, year.

The start date of the requisition in YYYY-MM-DD format

The state of the requisition. Can be one of processing, draft, pending, approved, open, filled, rejected, cancelled, reserved, on_hold.

Requisitions

Shortcodes

The type of the stage. Possible values are sourced, applied, shortlisted, assessment, phone-screen, interview, offer & hired.

The position of the stage in the pipeline (zero based).

Stages

Workable

Download Resume By Candidate Id

Accessible with all token types. Required scope: r_jobs.

Returns a collection of all the accounts you have access to.

Calling this endpoint will return the information about a specific account you have access to.

Returns the specified account

Accessible with account tokens and user tokens. Required scope: r_jobs.

Returns a collection of your account members

Returns a collection of your account external recruiters

Calling the /stages endpoint will return a collection of the recruitment pipeline stages as defined in recruiting preferences page.

Returns a collection of your recruitment pipeline stages.

Reject an offer

Returns a collection of the public jobs for an account

Returns a collection of the departments of the public jobs of the specified account

Returns a collection of the locations of the public jobs of the specified account

Retrieve a list of events for a specific employee

List all events

Get a specific event by ID

Use this endpoint for deleting subscriptions. It's recommended to delete obsolete subscriptions if you're a third party.

Unsubscribe from an event

Use this endpoint to list your subscriptions. Required scope: r_candidates or r_employees. Accessible with all token types.

List subscriptions

Subscribe to an event. Required scope: r_candidates or r_employees. Accessible with all token types. You can use this endpoint to register your service. The arguments object can be used to further filter which events you want to receive.

Subscribe to an event

This endpoint is used to upload documents for an employee. It requires the 'w_employees' scope which can be enabled through the integrations section found within the settings menu.

Uploads a list of documents for a specific employee.

Accessible with user level tokens and account level tokens that provide the member_id query param.

Returns a collection of the uploaded documents for a specific employee.

Updates an existing employee. Required scope: w_employees.

Updates an existing employee

Returns all relevant information for a specific employee. Required scope: r_employees. Accessible with user access tokens and with account level tokens that provide member_id query param.

Get specific employee information

This endpoint is used to create a new employee with various personal and professional details.

Creates an employee for your account.

Calling the /employees endpoint will return a collection of the available employees for the account. If you are using an account level token you will get only published employees with publicly available info. To get all types of employees there is a need to add member_id of an hr admin.

Returns a collection of your account employees

This endpoint returns a collection of the defined work schedules for the account. Required scope: r_account.

Returns a collection of your account work schedules

This endpoint returns a collection of the defined employee_fields for the account.

Returns a collection of your account employee_fields.

Returns a collection of the account's custom attributes.

Updates a custom attribute value for a candidate. Required scope: r_jobs. Accessible with all token types.

Updates a custom attribute value for a candidate.

Required scope: w_candidates. Accessible with all token types.

Creates a rating for a candidate

Calling the /candidates/:id/activities endpoint returns a JSON array of the candidate's activities.

Returns the activity stream of the given candidate

Moves the candidate to another stage. Required scope: w_candidates. Accessible with all token types. When an account has hiring plan enabled, in order to move a candidate to a stage of kind hired a requisition has to be filled.

Moves the candidate to another stage

Moves a candidate to another job. Required scope: w_candidates. Accessible with all token types. The only difference between the Copy and Relocate methods is that the Copy method preserves the source candidate while the Relocate method deletes it.

Moves a candidate to another job

Copies a candidate to another job. Required scope: w_candidates. Accessible with all token types.

Copies a candidate to another job

Reverts a candidate's disqualification. Required scope: `w_candidates`. Accessible with all token types.

Reverts a candidate's disqualification

Disqualifies a candidate. Required scope: `w_candidates`. Accessible with all token types.

Disqualifies a candidate

Updates candidate's tags. The tags list will be assigned to a candidate as is. If the array is empty, all tags of the candidate will be deleted.

Updates candidate's tags

Required scope: w_candidates or w_comments. Accessible with all token types.

Creates a comment on the candidate's timeline

Accessible with all token types. Required scope: r_candidates.

Returns the offer related data of the given candidate

This endpoint allows for partial updates to a candidate's information. It behaves like a PUT request for array keys (education_entries, experience_entries, social_profiles, tags), meaning the end result will match exactly the input provided. Any pre-existing entries not included in the request will be deleted.

Partially updates a candidate

Returns specified candidate

Creates a candidate at the specified job. Required scope: w_candidates. Accessible with all token types.

Creates a candidate at the specified job

This endpoint creates candidates in a specific job. It can be used for custom application forms, migration of existing candidates, or integration with other systems.

Accessible with all token types. By default results are limited to 50. The limit can be updated via the request parameter limit. The value specified cannot be more than 100 per page.

Returns a collection of the job's candidates

Calling the /jobs/{shortcode}/recruiters endpoint will return a collection of the external recruiters that are collaborators in the specified job.

Calling the /jobs/{shortcode}/members endpoint will return a collection of the defined members that are in the hiring team of the specified job. The role defined is on the account level.

Calling the endpoint will return a collection of the custom attributes that are applicable for the specified job.

Returns a collection of the custom attributes that are relevant to a specific job.

Calling the /stages endpoint will return a collection of the recruitment pipeline stages as defined in recruiting preferences page

Returns a collection of your recruitment pipeline stages

Returns the questions for the specified job

Required scope: r_jobs. Accessible with all token types.

Returns the details of the specified job

Calling the /jobs/{shortcode}/application_form endpoint returns a JSON object with two arrays, one with the application form fields and one array with the job's questions.

Returns the application form details for the specified job

Accessible with all token types. Requires scope `r_candidates`.

Returns the activity stream of the given job

Accessible with all token types. Results are sorted by the time inserted on system, in ascending order. By default, results are limited to 50 and can be updated via the `limit` request parameter up to a maximum of 100.

Returns a collection of your account jobs

Approves an offer (must be in a compatible state). Required scope: w_offers. Accessible only with user tokens.

Approves an offer

Accessible only with user tokens. Required scope: r_offers.

Returns an offer

Rejects a requisition (must be in a compatible state). Required scope: w_requisitions. Accessible with user tokens only.

Rejects a requisition

Approves a requisition (must be in a compatible state). Required scope: w_requisitions. Accessible with user tokens only.

Approves a requisition (must be in a compatible state).

Required scope: r_requisitions. Accessible with all token types.

Returns a requisition

By default results are limited to 50. The limit can be updated via the request parameter limit. The value specified cannot be more than 100.

Returns a collection of your account requisitions

Accessible with all token types. Required scope: r_account.

Returns a collection of your account legal entities.

Returns a collection of your account departments.

Greenhouse Harvest

Breezy HR

Lever

Ashby

Recruitee

# Continuous Import of Job Candidates to Your App

This scenario enables your application to continuously sync Job Candidates from any external application to your app's API. It handles the initial import of Job Candidates and keeps them synchronized when a Job Candidate is created, updated, or deleted in the external application.

When receiving Job Candidates data from the external application, the data is transformed into a format supported by your app's API. Additionally, if needed, your customers can customize the data mapping based on their specific external application setup.

## How It Works

1. **Initial Import**:
   - Perform the initial import by calling the Integration.app REST API or SDK in a loop from your code to retrieve data page by page.
   - Integration.app transforms the output into a consistent format compatible with your API, allowing you to save the data efficiently.

2. **Continuous Sync**:
   - Enable subscription via a single API or SDK call to continuously receive created, updated, or deleted events.
   - Integration.app manages all integration-specific logic, including subscribing to/unsubscribing from webhooks, custom polling of events, or performing periodic full syncs.
   - You will only receive the necessary events as real-time as supported by the external application's API.

Continuously Import Job Candidates to my App

Import Job Candidates and receive created/updated or deleted events

Quickbooks

BambooHR

NetSuite

Gusto

ADP Workforce Now

Rippling HR

Google Workspace

Sage HR

Deel

HiBob

Lightspeed R-Series

# Delete Employee

This scenario allows your application to delete a Employee from any external application. 
You will pass ID of the Employee you want to delete and Integration.app will handle the rest.

## How It Works

1. **Delete Employee API call**:
   - Call Integration.app REST API or SDK with ID of the Employee you want to delete and Integration.app will send the correct request to the external app.


Delete Employee

Deletes Employee in any external application

# Realtime Full two-way Sync of Job Candidates

This scenario enables your application to fully sync Job Candidates between your app and any external application in both directions. It handles the initial import/export of Job Candidates and then sends events when a Job Candidate is created, updated, or deleted on any side, as close to real-time as possible.

Job Candidate fields will be mapped from your application's schema to the application-specific schema.

## How It Works

1. **Initial Sync**:
   - Perform the initial import by calling the Integration.app REST API or SDK in a loop from your code to retrieve data page by page. Integration.app transforms the output into a consistent format compatible with your API, allowing you to save and match data efficiently.
   - Make another set of requests to create Job Candidates in external app, if needed.

2. **Continuous Sync from External App**:
   - Enable subscription via a single API or SDK call to continuously receive created, updated, or deleted events from external applications.
   - Integration.app manages all integration-specific logic, including subscribing to/unsubscribing from webhooks, custom polling of events, or performing periodic full syncs.
   - You will only receive the necessary events as real-time as supported by the external application's API.


2. **Continuous Sync from Your App**:
   - You will get a single webhook URI that you will use to send events about created, updated, or deleted Job Candidates to Integration.app.
   - Once send, Integration.app will map the webhook payload to the format supported by external application and send the correct request


Two-way realtime sync of Job Candidates

Bi-directional realtime sync of Job Candidates with records deduplication

# Create Job Candidate

This scenario allows your application to create a Job Candidate in any external application in the same way. 
You will pass Job Candidate fields in any format your application support and Integration.app will handle mapping of them to the schema of any selected application.
Additionally, if needed, your customers can customize the data mapping based on their specific setup.


## How It Works

1. **Configuration**:
   - You will setup the schema of fields that you wish to create Job Candidate with and configure mapping to our default model

2. **Create Job Candidate API call**:
   - Call Integration.app REST API or SDK with payload matching the field mapping you configured. You can run it for any external application via the same request.
   - When called, Integration.app transforms your Job Candidate data into a format compatible with the selected external application.
   - It then makes an API call to create the Job Candidate in that specific application.


Create Job Candidate

Creates Job Candidate in any external application

Workday

Personio

Isolved

Clio

UKG Ready

Everee

# Continuous Import of Employees to Your App

This scenario enables your application to continuously sync Employees from any external application to your app's API. It handles the initial import of Employees and keeps them synchronized when a Employee is created, updated, or deleted in the external application.

When receiving Employees data from the external application, the data is transformed into a format supported by your app's API. Additionally, if needed, your customers can customize the data mapping based on their specific external application setup.

## How It Works

1. **Initial Import**:
   - Perform the initial import by calling the Integration.app REST API or SDK in a loop from your code to retrieve data page by page.
   - Integration.app transforms the output into a consistent format compatible with your API, allowing you to save the data efficiently.

2. **Continuous Sync**:
   - Enable subscription via a single API or SDK call to continuously receive created, updated, or deleted events.
   - Integration.app manages all integration-specific logic, including subscribing to/unsubscribing from webhooks, custom polling of events, or performing periodic full syncs.
   - You will only receive the necessary events as real-time as supported by the external application's API.

Continuously Import Employees to my App

Import Employees and receive created/updated or deleted events

Jobnimbus

# Realtime Full two-way Sync of Jobs

This scenario enables your application to fully sync Jobs between your app and any external application in both directions. It handles the initial import/export of Jobs and then sends events when a Job is created, updated, or deleted on any side, as close to real-time as possible.

Job fields will be mapped from your application's schema to the application-specific schema.

## How It Works

1. **Initial Sync**:
   - Perform the initial import by calling the Integration.app REST API or SDK in a loop from your code to retrieve data page by page. Integration.app transforms the output into a consistent format compatible with your API, allowing you to save and match data efficiently.
   - Make another set of requests to create Jobs in external app, if needed.

2. **Continuous Sync from External App**:
   - Enable subscription via a single API or SDK call to continuously receive created, updated, or deleted events from external applications.
   - Integration.app manages all integration-specific logic, including subscribing to/unsubscribing from webhooks, custom polling of events, or performing periodic full syncs.
   - You will only receive the necessary events as real-time as supported by the external application's API.


2. **Continuous Sync from Your App**:
   - You will get a single webhook URI that you will use to send events about created, updated, or deleted Jobs to Integration.app.
   - Once send, Integration.app will map the webhook payload to the format supported by external application and send the correct request


Two-way realtime sync of Jobs

Bi-directional realtime sync of Jobs with records deduplication

# Create Employee

This scenario allows your application to create a Employee in any external application in the same way. 
You will pass Employee fields in any format your application support and Integration.app will handle mapping of them to the schema of any selected application.
Additionally, if needed, your customers can customize the data mapping based on their specific setup.


## How It Works

1. **Configuration**:
   - You will setup the schema of fields that you wish to create Employee with and configure mapping to our default model

2. **Create Employee API call**:
   - Call Integration.app REST API or SDK with payload matching the field mapping you configured. You can run it for any external application via the same request.
   - When called, Integration.app transforms your Employee data into a format compatible with the selected external application.
   - It then makes an API call to create the Employee in that specific application.


Create Employee

Creates Employee in any external application

# Realtime Full two-way Sync of Employees

This scenario enables your application to fully sync Employees between your app and any external application in both directions. It handles the initial import/export of Employees and then sends events when a Employee is created, updated, or deleted on any side, as close to real-time as possible.

Employee fields will be mapped from your application's schema to the application-specific schema.

## How It Works

1. **Initial Sync**:
   - Perform the initial import by calling the Integration.app REST API or SDK in a loop from your code to retrieve data page by page. Integration.app transforms the output into a consistent format compatible with your API, allowing you to save and match data efficiently.
   - Make another set of requests to create Employees in external app, if needed.

2. **Continuous Sync from External App**:
   - Enable subscription via a single API or SDK call to continuously receive created, updated, or deleted events from external applications.
   - Integration.app manages all integration-specific logic, including subscribing to/unsubscribing from webhooks, custom polling of events, or performing periodic full syncs.
   - You will only receive the necessary events as real-time as supported by the external application's API.


2. **Continuous Sync from Your App**:
   - You will get a single webhook URI that you will use to send events about created, updated, or deleted Employees to Integration.app.
   - Once send, Integration.app will map the webhook payload to the format supported by external application and send the correct request


Two-way realtime sync of Employees

Bi-directional realtime sync of Employees with records deduplication

# Update Employee

This scenario allows your application to update a Employee in any external application in the same way. 
You will pass  ID of the Employee you want to update and Employee fields in any format your application support and Integration.app will handle mapping of them to the schema of any selected application.
Additionally, if needed, your customers can customize the data mapping based on their specific setup.

## How It Works

1. **Configuration**:
   - You will setup the schema of fields that you wish to update Employee with and configure mapping to our default model

2. **Create Employee API call**:
   - Call Integration.app REST API or SDK with payload matching the field mapping you configured and ID. You can run it for any external application via the same request.
   - When called, Integration.app transforms your Employee data into a format compatible with the selected external application.
   - It then makes an API call to update the Employee in that specific application.


Update Employee

Updates Employee in any external application

# Update Job

This scenario allows your application to update a Job in any external application in the same way. 
You will pass  ID of the Job you want to update and Job fields in any format your application support and Integration.app will handle mapping of them to the schema of any selected application.
Additionally, if needed, your customers can customize the data mapping based on their specific setup.

## How It Works

1. **Configuration**:
   - You will setup the schema of fields that you wish to update Job with and configure mapping to our default model

2. **Create Job API call**:
   - Call Integration.app REST API or SDK with payload matching the field mapping you configured and ID. You can run it for any external application via the same request.
   - When called, Integration.app transforms your Job data into a format compatible with the selected external application.
   - It then makes an API call to update the Job in that specific application.


Update Job

# Enrich newly created Job Candidates

This scenario enables your application to enrich with the new data any newly createad Job Candidates in external application. 

It handles subscription to the created events and Job Candidate fields mapping from your application's schema to the application-specific schema.

## How It Works
1. **Configuration**:
   - You will setup the schema of fields that you wish to enrich Job Candidate with and configure mapping to our default model.
   - If needed - your customer can customize this mapping based on their specific setup or even custom fields

2. **Enable receiving of Job Candidate created events**:
   - Enable subscription via a single API or SDK call to continuously receive created events from external applications.
   - Integration.app manages all integration-specific logic, including subscribing to/unsubscribing from webhooks, custom polling of events, or performing periodic full syncs.
   - You will only receive the necessary events as real-time as supported by the external application's API.

2. **React to created Job Candidates**:
   - Integration.app flow will be launched when new Job Candidate is created
   - It will send existing data to your app API, so you can decide how to enrich. Your API will return enriched data.
   - Integration.app will send enriched data to the external application mapped to the supported format based on the configuration above


Continuously Enrich Job Candidates

Receive all newly created job-candidates, send it to your app API to enrich with the new data and update job-candidate back

# Continuous Import of Jobs to Your App

This scenario enables your application to continuously sync Jobs from any external application to your app's API. It handles the initial import of Jobs and keeps them synchronized when a Job is created, updated, or deleted in the external application.

When receiving Jobs data from the external application, the data is transformed into a format supported by your app's API. Additionally, if needed, your customers can customize the data mapping based on their specific external application setup.

## How It Works

1. **Initial Import**:
   - Perform the initial import by calling the Integration.app REST API or SDK in a loop from your code to retrieve data page by page.
   - Integration.app transforms the output into a consistent format compatible with your API, allowing you to save the data efficiently.

2. **Continuous Sync**:
   - Enable subscription via a single API or SDK call to continuously receive created, updated, or deleted events.
   - Integration.app manages all integration-specific logic, including subscribing to/unsubscribing from webhooks, custom polling of events, or performing periodic full syncs.
   - You will only receive the necessary events as real-time as supported by the external application's API.

Continuously Import Jobs to my App

Import Jobs and receive created/updated or deleted events

# Get all Job Candidates

This scenario enables your application to get a complete list of Job Candidates from any external application to your app's API in the same way. 

When receiving Job Candidates data from the external application, the data is transformed into a format supported by your app's API. Additionally, if needed, your customers can customize the data mapping based on their specific external application setup.

## How It Works

You will call a Integration.app REST API endpoint or SDK methods to retrieve a single page of Job Candidates along with the `cursor` if next page is available.
Repeate this request in a loop from your code to retrieve all Job Candidates page by page.


Get all Job Candidates

Imports all Job Candidates from any external application to your App.

Workable API Integration Profile