.png)
Workable Integration Guide
Integrate Workable recruiting data with enterprise systems through REST APIs, selected webhook notifications, scheduled workflows, and secure data transformation.
Workable integration options at a glance
Workable's primary integration mechanism is its REST API, which exposes recruiting data such as Jobs, Candidates, Stages, Offers, Members, and Locations for supported read and write operations. Workable also supports webhook-style notifications for selected recruiting events, although coverage should be confirmed for each required object and event. Martini can consume these APIs, receive notifications through an exposed endpoint, retrieve authoritative object state, and orchestrate downstream workflows. Scheduled synchronization provides a practical fallback where event coverage is incomplete. Candidate resumes and attachments may also be available through relevant endpoints, subject to account permissions and endpoint behavior.
| Integration point | Supported by Workable? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | List and retrieve Jobs, Candidates, Stages, Offers, Members, Locations, and related recruiting data; create or update supported resources and move Candidates through hiring stages. | Martini can consume Workable REST endpoints from workflows, map responses, apply business rules, and expose a separate Martini API when downstream systems need a controlled endpoint. |
| Webhooks / outbound callbacks | Limited | Receive notifications for selected recruiting events and use them to initiate downstream processing. | Martini can expose an HTTP endpoint or webhook workflow, validate the notification, retrieve current Workable data, and route the result to downstream systems. Coverage must be confirmed event by event. |
| Authentication | Yes | Authenticate public API requests using a Workable API token sent as a bearer token in the HTTP Authorization header. | Martini can store the token in secrets or secure environment configuration and apply it to Workable API requests without embedding credentials in workflows. |
| File / attachment APIs | Limited | Process resume or candidate attachment metadata and, where the endpoint permits, retrieve downloadable content or a temporary URL. | Martini can validate content types, route approved files, and apply retention and access controls, subject to the exact Workable endpoint response. |
| Scheduled synchronization | Yes | Poll Workable REST endpoints for Candidates, Jobs, Offers, or other objects when webhook coverage is incomplete or reconciliation is required. | Martini can invoke scheduled workflows, paginate through results, retain checkpoints where supported, and reconcile failed or missed changes. |
| Pagination and incremental synchronization | Yes | Process paginated list operations and use timestamps, cursors, page tokens, or comparison logic for incremental synchronization where available. | Martini workflows can manage pagination state, checkpoint progress, filter changes, and safely resume long-running synchronization. |
| Bulk / async / batch APIs | Not confirmed | A general-purpose Workable bulk or asynchronous API was not confirmed; standard list and write operations are the documented approach. | Martini can orchestrate batched calls using standard endpoints, but the implementation should not assume a native Workable bulk API. |
| GraphQL APIs | Not confirmed | No official Workable GraphQL API was confirmed in the supplied research. | Martini can use the confirmed Workable REST API instead. |
How Workable exposes data and business events
Workable REST APIs
Workable's REST API is the primary documented integration interface for retrieving and updating supported recruiting data, including Jobs, Candidates, Stages, Offers, Members, and Locations. Exact operations and permissions depend on the current API reference and Workable account configuration.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with a Workable bearer API token, calls the required REST endpoint, handles pagination, maps the response into a canonical model, applies business rules, and writes or exposes the result for downstream systems.
Implementation sequence
Workable webhook notifications
Workable supports webhook-style notifications for selected recruiting events. Notifications are not necessarily a complete event stream for every Workable object or field change, so event coverage should be confirmed for the required scenario.
Martini implementation pattern
Martini implementation pattern: expose an HTTP endpoint, validate and acknowledge the notification, identify the affected Workable object, retrieve authoritative current data through the REST API, and invoke downstream workflows. Longer processing can be separated from the acknowledgement path.
Implementation sequence
Scheduled Workable synchronization
Scheduled polling is appropriate when a required event is not covered by Workable notifications or when periodic reconciliation is needed. List operations should be treated as paginated.
Martini implementation pattern
Martini implementation pattern: a scheduler starts a workflow, the workflow retrieves pages of Workable data, compares checkpoints or timestamps where available, transforms changed objects, and records outcomes for retry and reconciliation.
Implementation sequence
Workable file and resume data
Candidate responses may expose resume or attachment-related metadata, a downloadable file, a temporary URL, or only a reference. The exact behavior must be confirmed for the relevant Workable endpoint and account.
Martini implementation pattern
Martini implementation pattern: retrieve only approved candidate file data, validate the content and access context, route it to an approved destination, and apply retention, logging, and personal-data controls.
Implementation sequence
Common Workable integration patterns
Pattern 1: Synchronize candidates to an HR system
When to use this pattern
Use this pattern when approved Candidates must be transferred from recruiting into an HR or employee system. A scheduled workflow or selected Workable notification can initiate processing, while stage and offer rules determine which candidates are eligible.
Integration direction
Example Mapping
| Workable Field | Canonical Field | Target Field |
|---|---|---|
| candidate.id | externalCandidateId | workerCandidateReference |
| candidate.name | personName | legalName |
| candidate.email | contactEmail | workEmail |
| candidate.stage | hiringStage | recruitingStatus |
Martini implementation pattern
Martini retrieves the Candidate and, when necessary, associated Job, Stage, and Offer data; validates required fields; filters by approved stage; maps the result to the target model; and performs an idempotent upsert. Failed writes are retried according to error type and included in reconciliation.
Martini capabilities used
- workflows
- API consumption
- scheduled triggers
- data mapping
- business rules
- error handling
Pattern 2: Publish approved jobs to a careers site
When to use this pattern
Use this pattern when published or approved Workable Jobs must be synchronized with a corporate website, careers portal, or external content platform. The workflow should also detect state changes that require unpublishing or archiving.
Integration direction
Example Mapping
| Workable Field | Canonical Field | Target Field |
|---|---|---|
| job.id | externalJobId | postingId |
| job.title | positionTitle | title |
| job.description | positionDescription | body |
| job.location | workLocation | location |
Martini implementation pattern
A scheduled Martini workflow retrieves paginated Jobs, selects approved or published positions, transforms descriptions and location data, and upserts postings using the Workable Job identifier. State changes are routed to update, archive, or unpublish actions, with validation and retry handling.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination
- data transformation
- conditional routing
- idempotency
- error handling
Pattern 3: Notify recruiting teams about candidate events
When to use this pattern
Use this pattern when recruiters need collaboration notifications for selected candidate or hiring-stage events. Workable's notification coverage should be confirmed, and the event should be treated as a trigger rather than a complete source of truth.
Integration direction
Example Mapping
| Workable Field | Canonical Field | Target Field |
|---|---|---|
| candidate.id | candidateReference | messageCandidateId |
| candidate.name | candidateDisplayName | messageText |
| candidate.stage | currentHiringStage | messageStage |
| job.title | relatedPosition | messageJob |
Martini implementation pattern
Martini receives the Workable notification, validates it, retrieves the current Candidate and related Job, applies channel and privacy rules, and sends a concise normalized message to Slack. Duplicate notifications are made safe through object identifiers and event metadata where available.
Martini capabilities used
- webhook workflows
- API consumption
- data enrichment
- business rules
- idempotency
- error handling
Pattern 4: Process approved offers for onboarding
When to use this pattern
Use this pattern when Offer and hiring-stage information must initiate an HRIS, onboarding, or payroll-preparation process. Candidate profile, stage, and offer data should be handled as separate concerns because their access requirements may differ.
Integration direction
Example Mapping
| Workable Field | Canonical Field | Target Field |
|---|---|---|
| candidate.id | externalCandidateId | sourceCandidateId |
| offer.status | offerStatus | onboardingEligibility |
| candidate.email | contactEmail | personalEmail |
| job.title | acceptedPosition | jobTitle |
Martini implementation pattern
Martini retrieves the current Candidate, Stage, and Offer, confirms the required status and consent rules, minimizes sensitive fields, and writes an idempotent onboarding request. Temporary failures are retried, while validation and authorization failures are quarantined for review.
Martini capabilities used
- workflows
- REST API consumption
- data mapping
- field minimization
- business rules
- retry handling
- reconciliation
Applications commonly integrated with Workable
Workable can be integrated with named enterprise applications to connect recruiting activity with employee administration, collaboration, scheduling, screening, and business processes. The exact direction and object scope should be confirmed for each implementation and tenant configuration.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Workday | Synchronize approved hires, selected job or requisition information, organizational references, and onboarding-related data between recruiting and HCM processes. | Workable → Martini → Workday | Use a scheduled or event-triggered workflow to retrieve Candidates, Stages, and Offers, apply approval and hiring-stage rules, map the result to Workday's target model, and retry or reconcile failed writes. |
| BambooHR | Transfer approved candidate or hired-employee information into employee records and reduce duplicate onboarding data entry. | Workable → Martini → BambooHR | Retrieve eligible Candidates and Offers from Workable, validate required fields, transform them into BambooHR employee data, and use Workable identifiers for idempotent updates. |
| Salesforce | Make selected recruiting information available to business workflows where hiring or recruiting data is needed in Salesforce. | Workable → Martini → Salesforce | Expose a controlled Martini API or run a scheduled workflow that maps approved Workable objects into Salesforce objects, with filtering to limit personal data and error handling for rejected writes. |
| Slack | Notify recruiting channels about selected candidate, job, interview, or hiring-stage events. | Workable → Martini → Slack | Receive a selected Workable notification, retrieve the current Candidate or Job when necessary, apply notification rules, and send a normalized message to the appropriate Slack channel. |
| Microsoft Teams | Deliver hiring-stage or interview notifications to recruiters and hiring teams in collaboration channels. | Workable → Martini → Microsoft Teams | Use a Martini webhook workflow to validate Workable notifications, enrich them with current REST API data, and route concise messages to Teams according to job, department, or stage rules. |
| Google Calendar | Coordinate interviews and recruiting schedules with interviewer calendars where the selected Workable scheduling design supports it. | Workable → Martini → Google Calendar | Orchestrate scheduling data between Workable and Google Calendar, normalize participant and time-zone fields, and use idempotent identifiers to avoid duplicate calendar events. |
| Zoom | Create or associate virtual interview meetings with candidate interview activities when supported by the chosen scheduling process. | Workable → Martini → Zoom | Trigger a workflow for an approved interview activity, create or retrieve meeting details through the available endpoints, and return or distribute the meeting reference while handling duplicate requests. |
| Checkr | Initiate background checks after a candidate reaches an approved stage and return screening status to recruiting operations. | Workable → Martini → Checkr → Martini | Retrieve eligible Workable Candidates, apply stage and consent rules, submit the screening request to Checkr, and update or notify Workable-related processes after status changes, subject to both systems' APIs and permissions. |
How to build a Workable integration in Martini
Objective
Establish Workable API access using the tenant's bearer API token and confirm the permitted operations and account scope.
Instructions in Martini
- Configure the Workable API base URL and required request headers.
- Store the API token in Martini secrets or secure environment configuration.
- Confirm permissions for the Jobs, Candidates, Stages, Offers, Members, and Locations operations required by the integration.
- Avoid placing tokens or sensitive candidate data directly in workflow definitions or logs.
Objective
Select event-driven, scheduled, or API-led initiation based on Workable's confirmed notification coverage and the synchronization requirement.
Instructions in Martini
- Use a Martini endpoint for selected Workable webhook notifications.
- Use a Scheduler Trigger when event coverage is incomplete or reconciliation is required.
- Define the objects, events, and business conditions that initiate processing.
- Treat webhook notifications as triggers and retrieve authoritative object state when needed.
Objective
Call the appropriate Workable REST endpoint and obtain complete, current data for the object being processed.
Instructions in Martini
- Retrieve the related Job, Candidate, Stage, Offer, Member, or Location as required.
- Handle pagination for list operations.
- Use timestamps, cursors, page tokens, or comparison logic where the endpoint supports incremental processing.
- Confirm the behavior of resume and attachment responses before downloading content.
Objective
Coordinate API calls, enrichment, conditional routing, target writes, and asynchronous or follow-up processing in a maintainable Martini workflow.
Instructions in Martini
- Separate webhook acknowledgement from longer downstream processing where appropriate.
- Route Candidates according to stage, offer, consent, and hiring-status rules.
- Use reusable workflow logic for common validation, mapping, and error handling.
- Keep candidate profile, stage, offer, and file processing independently controllable.
Objective
Convert Workable's recruiting model into the target system's canonical and application-specific fields.
Instructions in Martini
- Map stable Workable identifiers to external keys.
- Normalize names, email addresses, locations, statuses, and dates.
- Minimize personal and confidential data copied to downstream systems.
- Validate required fields and handle optional or changed Workable fields explicitly.
Objective
Create or update target records safely while preventing duplicates and enforcing business conditions.
Instructions in Martini
- Use upsert behavior where supported by the target system.
- Store Workable object identifiers in the target system.
- Prevent provisioning until the required stage or offer status is reached.
- Apply content-type and access checks before routing resumes or attachments.
Common Workable data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Jobs | Represent open positions, job descriptions, publication state, departments, locations, and hiring configuration. | Workday, Salesforce, corporate careers sites, content platforms | Martini retrieves and maps approved or published Jobs, uses the Workable Job identifier for upserts, and archives or unpublishes target postings when required. |
| Candidates | Represent applicants and candidate profiles, including contact details, source information, current stage, and resume-related data. | Workday, BambooHR, Salesforce, Checkr | Martini filters Candidates by stage or hiring status, validates and transforms fields, protects personal data, and uses stable identifiers for idempotent synchronization. |
| Stages | Represent the hiring pipeline stages through which Candidates progress. | Workday, Slack, Microsoft Teams, onboarding platforms | Martini applies stage-based business rules, triggers selected downstream actions, and prevents provisioning or notifications until required stages are reached. |
| Offers | Represent offer information associated with Candidates and Jobs. | Workday, BambooHR, payroll-preparation and onboarding platforms | Martini separates offer processing from general profile synchronization, restricts sensitive fields, validates status, and retries or reconciles downstream updates. |
| Members | Represent Workable users, recruiters, hiring managers, and other account participants. | Identity or organizational reference systems, collaboration platforms | Martini can retrieve supported Member data, map responsible users or owners, and apply account-scope and permission rules before propagation. |
| Locations | Represent locations associated with Jobs and recruiting operations. | Workday, careers sites, reporting or business systems | Martini normalizes location fields, maps them to target reference data, and handles optional or changed values through validation and controlled defaults. |
Authentication and security considerations
Bearer-token authentication
Workable's documented public API authentication pattern uses an API token in the HTTP Authorization header as a bearer token. OAuth 2.0 should not be assumed for the general public API unless explicitly documented for the specific scenario.
Secrets and access scope
Store Workable tokens in Martini secrets or secure environment configuration rather than embedding them in workflows. Confirm the token's account context, permissions, and enabled operations before deployment.
Candidate data protection
- Minimize candidate, offer, resume, and attachment fields copied downstream.
- Restrict access to Martini APIs, workflows, logs, and outputs.
- Mask personal data in diagnostic logs and define retention and deletion behavior.
- Validate file content types and access context before routing resumes or attachments.
Operational considerations for Workable integrations
Rate limits and pagination
Confirm current Workable limits and treat list operations as paginated. Use scheduled workflow controls, checkpoints, and backoff to avoid bursts and safely resume long-running synchronization.
Idempotency and webhook reliability
Use Workable object identifiers as external keys and make repeated notifications safe. Acknowledge webhook requests promptly where required, then retrieve current object state for authoritative processing.
Schema and status changes
Optional fields and enumerated values such as stages and job statuses may change. Validate required fields, version mappings when target schemas change, and handle missing objects explicitly.
Testing and reconciliation
Test pagination, concurrent updates, duplicate notifications, rate-limit responses, permission failures, attachment behavior, and downstream errors. Periodic reconciliation can identify missed notifications and repair failed writes.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration beyond a script
Martini provides workflows for combining Workable API calls, selected webhook triggers, scheduled synchronization, validation, business rules, target writes, and reconciliation in a maintainable integration asset.
Reusable transformation and control
Mappings, field minimization, stage-based routing, idempotency, retries, and error handling can be applied consistently across Workable integrations instead of being duplicated in point-to-point scripts.
Controlled enterprise APIs
Martini can expose APIs for downstream applications, keep Workable credentials in secure configuration, and separate webhook acknowledgement from longer-running processing. This supports controlled access without assuming a dedicated vendor connector.
Frequently asked questions
Workable can be integrated primarily through its REST API, which supports access to recruiting data such as Jobs, Candidates, Stages, Offers, Members, and Locations. Workable also supports selected webhook-style notifications, while scheduled API synchronization can cover scenarios where event coverage is incomplete. Resume and attachment handling depends on the relevant endpoint and account configuration.
Yes. Martini can consume Workable's REST API, receive selected Workable webhook notifications through an exposed endpoint, orchestrate scheduled synchronization, map recruiting data, and route results to enterprise applications. A dedicated native Martini Workable connector is not documented in the supplied context.
No. A dedicated Workable connector is not required. Martini can integrate using Workable's confirmed native REST API, selected webhook notifications, bearer-token authentication, and supported file or attachment responses.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Workable. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Workable, cloud infrastructure, or other third-party systems depending on subscriptions, usage, and deployment model.
Use the Workable REST API as the primary method for retrieving and updating supported recruiting data. Use selected webhook notifications for responsive processing where the required event is covered, and scheduled synchronization for incomplete event coverage, pagination, and reconciliation. Workable GraphQL and SOAP APIs were not confirmed.
No blanket coverage should be assumed. Workable supports webhook-style notifications for selected recruiting events, but notifications are not necessarily a complete event stream for every object or field change. Martini can receive a notification, then retrieve the current Workable object through the REST API as the authoritative source.
Martini workflows can paginate through Workable list responses, retain a cursor, timestamp, page token, or equivalent checkpoint where supported, and transform data into a canonical target model. Stable Workable object identifiers should be stored and used for idempotent upserts; webhook event identifiers or timestamps can provide additional duplicate protection when available.
Separate authentication, permission, validation, rate-limit, transient, missing-object, and downstream errors so each can receive an appropriate response. Martini can retry transient failures with backoff, log outcomes for reconciliation, and validate resumes or attachments before routing them. Candidate profiles, offers, and resumes should be minimized, access-controlled, and protected from unnecessary logging.
Related Martini documentation
Data processing
Security operations
Connect Workable with your enterprise systems
Use Martini to build maintainable Workable integrations with REST APIs, selected webhook notifications, scheduled synchronization, secure data handling, and enterprise workflow orchestration.