# Workable MCP MCP

> Workable MCP connects your AI agent directly to a professional Applicant Tracking System (ATS). It lets you manage every phase of hiring, from listing job openings across dozens of boards to tracking candidate progress and registering new talent. Check status updates for specific candidates or get full details on active roles—all without opening the Workable dashboard. This is core recruiting automation.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** applicant-tracking, hiring-workflow, candidate-screening, job-board-integration, recruitment-automation, talent-acquisition

## Description

Managing a hiring funnel means constantly jumping between dashboards: checking open roles, reviewing application statuses, and making sure the team knows who's doing what. Your AI agent handles that overhead for you. You can ask it to list all current job openings or pull up an entire candidate history just by asking a natural question. If you need to find out how many jobs are open in London versus New York, your agent gets that data instantly and presents it clearly. Because the hiring process often touches multiple systems—like sending messages after an interview, then updating payroll records—the real power comes from chaining this Workable MCP with other services through Vinkius. This means you can build automations that span job tracking, messaging, and billing platforms all within a single workflow. Your agent handles the data handoffs so you don't have to copy anything.


## Tools

### create_candidate
Adds a new person's profile and registers them against a specific job opening.

### get_candidate_profile
Retrieves all personal details, experience notes, and current status for one candidate.

### get_job_details
Gets the full description, requirements, and metadata for a single job posting.

### list_account_members
Lists all people who have access to your Workable account settings.

### list_all_candidates
Provides a summary list of every candidate currently tracked across the entire job board inventory.

### list_jobs
Gives you an overview and listing of all current and past job openings.

### list_linked_accounts
Shows which external systems, like payroll or CRM tools, are connected to Workable.

## Prompt Examples

**Prompt:** 
```
List all active job openings in our Workable account.
```

**Response:** 
```
I've retrieved your active jobs. You have 4 openings: 'Senior Frontend Engineer', 'Product Designer', 'DevOps Specialist', and 'Marketing Lead'. Which one would you like to see the details for?
```

**Prompt:** 
```
Show me the details for the candidate 'John Smith'.
```

**Response:** 
```
I've fetched John Smith's profile. He is currently in the 'Interview' stage for the 'Senior Frontend Engineer' role. He has 8 years of experience and is marked as 'Highly Recommended'.
```

**Prompt:** 
```
Add 'Jane Doe' (jane.doe@example.com) as a candidate for the job 'ENG-101'.
```

**Response:** 
```
Success! Jane Doe has been registered as a new candidate for job 'ENG-101' (shortcode: senior-frontend). I've added her email and initiated the application process.
```

## Capabilities

### List Active Job Openings
Retrieve a list of every job opening, whether it’s active or archived.

### Check Candidate Status
Pull up full profiles and current statuses for any candidate in the system.

### Find Job Specific Details
Get a deep dive into one job opening, including all requirements and descriptions.

### Register New Talent
Add external leads or new applicants directly to a specific job posting.

### View Team Structure
List the account members, letting you understand who on your team is assigned to recruiting tasks.

### Audit Connected Services
See which external accounts are linked and configured within your Workable instance.

## Use Cases

### Cold Lead Intake
A networking event yields ten excellent contacts. Instead of manually entering them one by one into Workable, you tell your agent to 'Add these ten people as candidates for the Senior Developer role.' The agent uses `create_candidate` for immediate tracking.

### Pipeline Status Check
It's Friday afternoon. You need a quick report on all active hiring efforts. Your agent runs `list_jobs`, then uses that data to pull candidate summaries via `list_all_candidates` so you can send an end-of-week progress email.

### Team Handover
A recruiter leaves the company. You need to know who else has access to the account settings and job boards. Your agent calls `list_account_members` and then cross-references that data with linked systems using `list_linked_accounts`.

### Job Scope Validation
Before writing a full job description, you want to ensure the tech stack matches the company's current setup. You ask your agent to pull `get_job_details`, confirming that every requirement listed is accurate and up-to-date.

## Benefits

- Never lose track of a lead again. Use `list_all_candidates` to see every person in the system, even if they aren't attached to an open role right now.
- Speed up sourcing by using `create_candidate` directly from your agent. You can register a promising contact immediately without manual dashboard steps.
- Get full context on roles with `get_job_details`. Instead of opening the job board, you ask your agent for the specific requirements and tech stack needed.
- Audit your team's involvement by calling `list_account_members`, ensuring every recruiter knows who owns which part of the hiring process.
- Keep an eye on connected services. Use `list_linked_accounts` to verify that your ATS is properly communicating with other business tools, like payroll.

## How It Works

The bottom line is: you talk to your agent in plain English; the agent talks to Workable using structured APIs.

1. First, subscribe to the Workable MCP and enter your Workable Subdomain and API Key.
2. Next, connect this MCP via your AI client (Claude, Cursor, or any MCP-compatible client).
3. Finally, ask your agent a natural language question, like 'List all active job openings,' and it runs the data retrieval for you.

## Frequently Asked Questions

**How do I find out what jobs are currently posted in Workable?**
Run the `list_jobs` tool. This gives you an overview of every active and archived job opening, letting you know exactly what roles you're managing right now.

**What is the best way to check a candidate's history using Workable MCP?**
Call `get_candidate_profile` with the person’s name or ID. This pulls all their associated data, including past experience and current status within your hiring pipeline.

**Can I use `list_account_members` to see who can access my Workable account?**
Yes, running `list_account_members` lists every person with credentials for the Workable workspace. This helps you audit your team's permissions.

**How do I add a new contact using the Workable MCP?**
Use the `create_candidate` tool. Just provide the name, email, and which job opening they should be registered against.

**What kind of details can I get about a specific job using `get_job_details`?**
It retrieves the full metadata for any single opening. You'll get things like the official job description, required qualifications, and even the short code associated with that posting.

**How do I check if my Workable account is connected to other external systems using `list_linked_accounts`?**
The tool lists all accounts linked to your Workable instance. This confirms which internal or third-party services are active and available for the agent to use.

**When I need to register several candidates, is there a way to handle bulk entries with `create_candidate`?**
The tool registers one candidate per call. To process multiple people quickly, structure your prompt to make consecutive calls for each individual.

**Can I filter the results when I run `list_all_candidates`?**
Yes, you can narrow down the list by providing status updates or specific job shortcodes. This lets your agent focus on only the candidates that matter to your current pipeline.