API Documentation
We are building intelligent AI APIs to enable ultra-fast, optimal hiring. Currently beta testing with early adopters. Join us in shaping the AI-driven future of hiring.
Introduction
Some Other Description
Resume Parser API
The Resume Parse API extracts key information from resumes (PDF, DOCX, TXT) and structures it into searchable data. It automates recruitment by identifying contact details, work experience, education, and skills, enhancing hiring efficiency and improving talent management.
Resume Parse API
The Resume Parse API extracts key information from resumes (PDF, DOCX, TXT) and structures it into searchable data. It automates recruitment by identifying contact details, work experience, education, and skills, enhancing hiring efficiency and improving talent management.
POST
https://apis.whitetable.ai/resume
Authentication
Authentication token that must be included in the request headers for authentication purposes. The client must securely store and manage this token, which is required to access protected API endpoints. The token should be sent in the following format:
token: <your-token-here>
Security Requirements:
The client is responsible for securely storing the token, using secure mechanisms (e.g., encrypted storage)
Do not hardcode or expose the token in client-side code or publicly accessible files
The server will return a 401 Unauthorized error if
The token is missing, expired, or invalid
The token does not meet the required policy for the requested resource
Body
resume
string
Required
Resume URL of the file you want to be parsed, File Type should be either pdf, txt, doc or docx, No other formats allowed. URL to the file should be either from private server or from google drive
{
"resume": "{RESUME_URL}"
}
Rate Limiting
To ensure fair usage, the API enforces rate limiting. Clients are allowed 100 requests per minute. Exceeding this limit will result in a 429 Too Many Requests error. If you encounter this, you should implement an exponential backoff strategy
Change Logs
v1.0
Initial release of the Resume API
curl -X POST https://apis.whitetable.ai/resume
-H 'token: {AUTH_TOKEN}'
-H 'Content-Type: application/json'
-d {
"resume": "{RESUME_URL}"
}
"root": {
"name": string "John Doe"
"email": string "johndoe@example.com"
"phone": string "+1-555-123-4567"
"work_experience": [
[0]: {
"position": string "Software Engineer"
"company": string "Tech Innovators"
"start_date": string "2018-06-01"
"end_date": string "2022-08-31"
}
]
"skills": [
[0]: string "Python"
[1]: string "API Development"
[2]: string "Cloud Computing"
[3]: string "DevOps"
]
"education": [
[0]: {
"degree": string "B.S. Computer Science"
"institution": string "Stanford University"
"graduation_year": string "2017"
}
]
}
Question API
The Question API allows you to generate customized interview questions for different stages of the recruitment process based on job descriptions and candidate resumes. This API is divided into two major functionalities: generating standard question rounds and generating personalized interview questions based on candidate profiles.
Standard Questions - Question API 1
This API endpoint generates a standard set of questions based on a job description (JD) and the interview round type
POST
https://apis.whitetable.ai/questions/init-round
Authentication
Authentication token that must be included in the request headers for authentication purposes. The client must securely store and manage this token, which is required to access protected API endpoints. The token should be sent in the following format:
token: <your-token-here>
Security Requirements:
The client is responsible for securely storing the token, using secure mechanisms (e.g., encrypted storage)
Do not hardcode or expose the token in client-side code or publicly accessible files
The server will return a 401 Unauthorized error if
The token is missing, expired, or invalid
The token does not meet the required policy for the requested resource
Body
jobDescription
string
Required
A string containing the job description, which the API uses to create relevant questions
questionCount
int
Required
Number of questions to be generated (max 20 per request)
roundName
string
Required
A custom name assigned to the round for organizing and tracking purposes
roundType
enum
Required
Defines the focus of the interview round (see detailed explanations below)
Acceptable Values:
It determines the overall focus of the interview round. Each value corresponds to a different set of skills or areas of evaluation.
technical: Focuses on the technical expertise of the candidate, assessing their understanding of tools, technologies, or specific job-related knowledge
Use Case: Suitable for roles where technical proficiency is critical, such as marketing roles that require knowledge of data analytics or tools like Google Analytics
Example: How do you define key performance metrics for a marketing campaign?
deep_dive: Focuses on in-depth technical knowledge in specific areas. This round is meant to evaluate the candidate’s expertise and hands-on experience in particular tools, technologies, or strategies.
Use Case: For candidates expected to have specialized knowledge in tools like Salesforce or advanced SEO techniques
Example: Can you describe your approach to automating marketing tasks?
problem_solving: Tests the candidate's ability to approach and solve complex problems. This assesses critical thinking, analytical skills, and real-world decision-making abilities
Use Case: Roles where adaptability and problem-solving are key, such as in sales or business development
Example: Describe a time when you had to pivot a strategy to meet KPIs under tight constraints
non_technical: Focuses on soft skills, such as communication, teamwork, and interpersonal abilities. It evaluates how the candidate handles non-technical responsibilities and interactions
Use Case: Used for roles where client communication or team collaboration is central, such as account management or sales roles
Example: How do you communicate technical details to non-technical clients?
pre_screening: A round designed to assess whether the candidate meets basic qualifications and fits the initial criteria for the job
Use Case: Useful in the early stages of recruitment to filter candidates based on minimal requirements
Example: Do you have experience managing email marketing campaigns?
cultural_fit: Assesses whether the candidate aligns with the company’s culture and values. Questions will probe into teamwork, adaptability, and how well the candidate will fit within the organizational culture
Use Case: Often used to assess potential hires for roles in dynamic or tightly-knit teams
Example: What work environment helps you thrive?
dsa: This round focuses on evaluating the candidate's knowledge of Data Structures & Algorithms. Primarily used for technical roles like software development or data science
Use Case: Used when evaluating software engineers or data scientists
Example: Explain how you would optimize a given algorithm for faster performance
focusArea
enum
Optional
The focus_area parameter allows you to fine-tune the interview questions generated by the API. It narrows down the broader evaluation set defined by the round_type and focuses on specific areas of expertise
If not specified, the API will generate questions based on the default focus for the selected round_type. If specified, the focus area allows a deeper or more refined assessment in specific domains
Example of focusArea Values (Based on round_type):
For round_type "technical": Overall technical aspects
For round_type "deep_dive": Depth of knowledge
For round_type "problem_solving": Problem-solving skills and critical thinking
For round_type "non_technical": Non-technical aspects
For round_type "pre_screening": Basic requirements fit
For round_type "cultural_fit": Cultural aspect
For round_type "dsa": Algorithms
{
"jobDescription": "{JOB_DESCRIPTION}",
"questionCount": "{NUMBER_OF_QUESTIONS}",
"roundName": "{ROUND_NAME}",
"roundType": "{ROUND_TYPE}",
"focusArea": "{FOCUS_AREA}"
}
Rate Limiting
To ensure fair usage, the API enforces rate limiting. Clients are allowed 100 requests per minute. Exceeding this limit will result in a 429 Too Many Requests error. If you encounter this, you should implement an exponential backoff strategy
Change Logs
v1.0
Initial release of the Question API
curl -X POST https://apis.whitetable.ai/questions/init-round
-H 'token: {AUTH_TOKEN}'
-H 'Content-Type: application/json'
-d {
"jobDescription": "{JOB_DESCRIPTION}",
"questionCount": "{NUMBER_OF_QUESTIONS}",
"roundName": "{ROUND_NAME}",
"roundType": "{ROUND_TYPE}",
"focusArea": "{FOCUS_AREA}"
}
"root": {
"questions": [
[0]: string "What metrics do you use to track the success of an online marketing campaign?"
[1]: string "Can you describe a time when you had to change your strategy based on performance data?"
[2]: string "How do you handle conflicts in a team when working towards a tight deadline?"
]
}
Personalized Questions - Question API 2
This API generates personalized interview questions based on a candidate's resume and the previously created round.
POST
https://apis.whitetable.ai/questions/interview
Authentication
Authentication token that must be included in the request headers for authentication purposes. The client must securely store and manage this token, which is required to access protected API endpoints. The token should be sent in the following format:
token: <your-token-here>
Security Requirements:
The client is responsible for securely storing the token, using secure mechanisms (e.g., encrypted storage)
Do not hardcode or expose the token in client-side code or publicly accessible files
The server will return a 401 Unauthorized error if
The token is missing, expired, or invalid
The token does not meet the required policy for the requested resource
Body
noq
int
Required
Number of questions to be generated (max 20 per request)
resume
string
Required
URL to the candidate’s resume file (PDF, DOC, DOCX, or TXT formats)
round_id
string
Required
The unique identifier for the interview round (from the Question API 1)
{
"noq": "{NUMBER_OF_QUESTIONS}",
"resume": "{RESUME_URL}",
"round_id": "{ROUND_ID}"
}
Rate Limiting
To ensure fair usage, the API enforces rate limiting. Clients are allowed 100 requests per minute. Exceeding this limit will result in a 429 Too Many Requests error. If you encounter this, you should implement an exponential backoff strategy
Change Logs
v1.0
Initial release of the Question API
curl -X POST https://apis.whitetable.ai/questions/interview
-H 'token: {AUTH_TOKEN}'
-H 'Content-Type: application/json'
-d {
"noq": "{NUMBER_OF_QUESTIONS}",
"resume": "{RESUME_URL}",
"round_id": "{ROUND_ID}"
}
"root": {
"questions": [
[0]: string "Based on your experience with Google Analytics, how do you track and optimize customer journeys?"
[1]: string "Describe a successful marketing campaign you have led. What tools did you use, and what were the key challenges?"
]
}
FIT API
The WT_FIT_Score API uses AI to instantly match resumes with job descriptions, providing a clear FIT Score (0-100) and detailed insights into a candidate’s strengths and gaps. It streamlines resume screening, saves time, and helps recruiters make faster, data-driven hiring decisions
Create FIT Job - FIT API 1
This API endpoint processes a job description (JD) and optimizes it for effective resume matching. It parses, analyzes, and standardizes the JD to ensure compatibility with subsequent matching algorithms.
POST
https://apis.whitetable.ai/fit
Authentication
Authentication token that must be included in the request headers for authentication purposes. The client must securely store and manage this token, which is required to access protected API endpoints. The token should be sent in the following format:
token: <your-token-here>
Security Requirements:
The client is responsible for securely storing the token, using secure mechanisms (e.g., encrypted storage)
Do not hardcode or expose the token in client-side code or publicly accessible files
The server will return a 401 Unauthorized error if
The token is missing, expired, or invalid
The token does not meet the required policy for the requested resource
Body
jobDescription
string
Required
A Detailed Description Of The Job Role, Responsibilities
salary
object
Required
Defines The Salary Range Offered For The Job
min
number
Required
Minimum Salary Offered For The Role
max
number
Required
Maximum Salary Offered For The Role
experience
object
Required
Specifies the required years of professional experience for the role.
min
number
Required
Minimum years of experience required
max
number
Required
Maximum years of experience accepted
{
"jobDescription": "{JOB_DESCRIPTION}",
"salary": {
"min": "{MINIMUN_SALARY}",
"max": "{MAXIMUM_SALARY}"
},
"experience": {
"min": "{MINIMUN_EXPERIENCE}",
"max": "{MAXIMUM_EXPERIENCE}"
}
}
Rate Limiting
To ensure fair usage, the API enforces rate limiting. Clients are allowed 100 requests per minute. Exceeding this limit will result in a 429 Too Many Requests error. If you encounter this, you should implement an exponential backoff strategy
Change Logs
v1.0
Initial release of the Create FIT Job API
curl -X POST https://apis.whitetable.ai/fit
-H 'token: {AUTH_TOKEN}'
-H 'Content-Type: application/json'
-d {
"jobDescription": "{JOB_DESCRIPTION}",
"salary": {
"min": "{MINIMUN_SALARY}",
"max": "{MAXIMUM_SALARY}"
},
"experience": {
"min": "{MINIMUN_EXPERIENCE}",
"max": "{MAXIMUM_EXPERIENCE}"
}
}
"root": {
"fitJobId": string "999999999999999999999999"
"analysis": {
"critical": [
[0]: string "Skill"
]
"essential": [
[0]: string "Skill"
]
"supporting": [
[0]: string "Skill"
]
"nicetohave": [
[0]: string "Skill"
]
}
}
Create FIT Score - FIT API 2
The Create FIT Score API calculates a FIT Score by analyzing a FIT Job and comparing it with candidate resumes. It uses the provided FIT Job ID and resume URLs to determine compatibility and relevance.
POST
https://apis.whitetable.ai/fit/score
Authentication
Authentication token that must be included in the request headers for authentication purposes. The client must securely store and manage this token, which is required to access protected API endpoints. The token should be sent in the following format:
token: <your-token-here>
Security Requirements:
The client is responsible for securely storing the token, using secure mechanisms (e.g., encrypted storage)
Do not hardcode or expose the token in client-side code or publicly accessible files
The server will return a 401 Unauthorized error if
The token is missing, expired, or invalid
The token does not meet the required policy for the requested resource
Body
fitJobId
string
Required
The unique identifier for the FIT Job (from the Create FIT Job API 1)
resume
string
Required
URL to the candidate’s resume file (PDF, DOC, DOCX, or TXT formats)
salary
number
Required
Current salary of the candidate in LPA
{
"fitJobId": "{FIT_JOB_ID}",
"resume": "{CANDIDATE_RESUME_URL}",
"salary": "{CANDIDATE_SALARY}"
}
Rate Limiting
To ensure fair usage, the API enforces rate limiting. Clients are allowed 100 requests per minute. Exceeding this limit will result in a 429 Too Many Requests error. If you encounter this, you should implement an exponential backoff strategy
Change Logs
v1.0
Initial release of the Create FIT Score API
curl -X POST https://apis.whitetable.ai/fit/score
-H 'token: {AUTH_TOKEN}'
-H 'Content-Type: application/json'
-d {
"fitJobId": "{FIT_JOB_ID}",
"resume": "{CANDIDATE_RESUME_URL}",
"salary": "{CANDIDATE_SALARY}"
}
"root": {
"score": float 112.06
"pros": [
[0]: string "Educational requirement"
[1]: string "worked at prefered company"
]
"avg": [
[0]: string "Node.js & Express.js Backend Development"
]
"cons": [
[0]: string "Version Control (Git)"
]
"analysis": {
"critical": [
[0]: {
"parameter": string "Node.js & Express.js Backend Development"
"rating": int 1
"explaination": string "The resume does not explicitly mention Node.js or Express.js development, nor does it describe the candidate's direct involvement in writing backend code."
"evidence": [
[0]: string "No evidence was found in the resume to support this skill or competence."
]
}
]
"essential": [
[0]: {
"parameter": string "Code Quality & Best Practices"
"rating": int 1
"explaination": string "The resume does not provide specific examples or mentions of the candidate's involvement in ensuring code quality, testing, or adherence to coding best practices."
"evidence": [
[0]: string "No evidence was found in the resume to support this skill or competence."
]
}
]
"supporting": [
[0]: {
"parameter": string "Full MERN Stack Familiarity (React.js)"
"rating": int 1
"explaination": string "The resume does not provide any evidence of familiarity with React.js or the MERN stack."
"evidence": [
[0]: string "No evidence was found in the resume to support this skill or competence."
]
}
]
"nicetohave": [
[0]: {
"parameter": string "CICD"
"rating": int 5
"explaination": string "The candidate explicitly built a staging environment with CI/CD, demonstrating hands-on experience in implementing and optimizing deployment processes with quantifiable results."
"evidence": [
[0]: string "Built a staging environment with version control for CI/CD, reducing deployment errors by 40% and accelerating release cycles."
]
}
]
}
"status": string "R-1"
}
Update FIT Job Analysis - FIT API 3
This API endpoint update the job analysis parameter and optimizes it for effective resume matching.
PUT
https://apis.whitetable.ai/fit
Authentication
Authentication token that must be included in the request headers for authentication purposes. The client must securely store and manage this token, which is required to access protected API endpoints. The token should be sent in the following format:
token: <your-token-here>
Security Requirements:
The client is responsible for securely storing the token, using secure mechanisms (e.g., encrypted storage)
Do not hardcode or expose the token in client-side code or publicly accessible files
The server will return a 401 Unauthorized error if
The token is missing, expired, or invalid
The token does not meet the required policy for the requested resource
Body
fitJobId
string
Required
The unique identifier for the FIT Job (from the Create FIT Job API 1)
analysis
object
Required
Object containing critical, essential, supporting and nicetohave parameters in string
critical
array
Required
The must-have requirements for the role. Without these, a candidate is unlikely to qualify
essential
array
Required
The important requirements that significantly impact a candidate’s suitability but may allow some flexibility
supporting
array
Required
The valuable but not mandatory skills that help a candidate stand out
nicetohave
array
Required
The optional extras that would be advantageous but are not expected
{
"fitJobId": "{JOB_DESCRIPTION}",
"analysis": {
"critical": [
"{LIST_OF_CRITICALS}"
],
"essential": [
"{LIST_OF_ESSENTIALS}"
],
"supporting": [
"{LIST_OF_SUPPORTING}"
],
"nicetohave": [
"{LIST_OF_NICETOHAVE}"
]
}
}
Rate Limiting
To ensure fair usage, the API enforces rate limiting. Clients are allowed 100 requests per minute. Exceeding this limit will result in a 429 Too Many Requests error. If you encounter this, you should implement an exponential backoff strategy
Change Logs
v1.0
Initial release of the Create FIT Job API
curl -X PUT https://apis.whitetable.ai/fit
-H 'token: {AUTH_TOKEN}'
-H 'Content-Type: application/json'
-d {
"fitJobId": "{JOB_DESCRIPTION}",
"analysis": {
"critical": [
"{LIST_OF_CRITICALS}"
],
"essential": [
"{LIST_OF_ESSENTIALS}"
],
"supporting": [
"{LIST_OF_SUPPORTING}"
],
"nicetohave": [
"{LIST_OF_NICETOHAVE}"
]
}
}
"root": {
"analysis": {
"critical": [
[0]: string "Skill"
]
"essential": [
[0]: string "Skill"
]
"supporting": [
[0]: string "Skill"
]
"nicetohave": [
[0]: string "Skill"
]
}
}