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
noq
int
Required
Number of questions to be generated (max 20 per request)
jd
string
Required
A string containing the job description, which the API uses to create relevant questions
round_name
string
Required
A custom name assigned to the round for organizing and tracking purposes
round_type
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
focus_area
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 focus_area 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
{
"noq": "{NUMBER_OF_QUESTIONS}",
"jd": "{JOB_DESCRIPTION}",
"round_name": "{ROUND_NAME}",
"round_type": "{ROUND_TYPE}",
"focus_area": "{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 {
"noq": "{NUMBER_OF_QUESTIONS}",
"jd": "{JOB_DESCRIPTION}",
"round_name": "{ROUND_NAME}",
"round_type": "{ROUND_TYPE}",
"focus_area": "{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 string containing the job description, which the API uses for Analysis
minSalary
number
Required
A number containing the minimum salary of job, which the API uses for Analysis
maxSalary
number
Required
A number containing the maximum salary of job, which the API uses for Analysis
minExperience
number
Required
A number containing the minimum experience needed for job, which the API uses for Analysis
maxExperience
number
Required
A number containing the maximum experience allocated for job, which the API uses for Analysis
{
"jobDescription": "{JOB_DESCRIPTION}",
"minSalary": "{MIN_SALARY}",
"maxSalary": "{MAX_SALARY}",
"minExperience": "{MIN_EXPERIENCE}",
"maxExperience": "{MAX_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}",
"minSalary": "{MIN_SALARY}",
"maxSalary": "{MAX_SALARY}",
"minExperience": "{MIN_EXPERIENCE}",
"maxExperience": "{MAX_EXPERIENCE}"
}
"root": {
"fit": {
"fitJobId": string "999999999999999999999999"
"sc_list": {
"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
id
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)
current_salary
number
Required
Current salary of the candidate in LPA
{
"id": "{FIT_JOB_ID}",
"resume": "{CANDIDATE_RESUME_URL}",
"current_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 {
"id": "{FIT_JOB_ID}",
"resume": "{CANDIDATE_RESUME_URL}",
"current_salary": "{CANDIDATE_SALARY}"
}
"root": {
"score": float 112.06
"pros": [
[0]: string "Educational requirement"
[1]: string "worked at prefered company"
[2]: string "Performance Optimization"
[3]: string "Troubleshooting & Debugging"
[4]: string "Collaboration & Communication"
[5]: string "Problem-Solving & Analytical Skills"
[6]: string "CICD"
]
"avg": [
[0]: string "Node.js & Express.js Backend Development"
[1]: string "MongoDB & NoSQL Database Management"
[2]: string "RESTful API Design & Development"
[3]: string "JavaScript Proficiency (ES6+)"
[4]: string "Code Quality & Best Practices"
[5]: string "Security Implementation"
[6]: string "Full MERN Stack Familiarity (React.js)"
[7]: string "Continuous Learning & Staying Updated"
]
"cons": [
[0]: string "Version Control (Git)"
]
"background_insight": {
"prefered_company_work": {
"explaination": string "The candidate has worked at Wipro Ltd., which is a prominent global IT services and consulting company. Wipro's business model aligns perfectly with the definition of a pure service-based company, providing IT consulting, software development, and outsourcing services across multiple industries without primarily selling its own products or SaaS. RootEnRoute Agridigital Pvt. Ltd. is a product-based company, as it built and scaled its own marketplace."
"list_service_based_company_names": [
[0]: string "Wipro Ltd."
]
}
"education_requirements": {
"score": int 100
"explaination": string "The job description did not specify any required education. The candidate holds a B.Tech from the Indian Institute of Technology (BHU) Varanasi, which is a highly reputable institution, indicating a strong educational background."
}
}
"flat_scores": {
"edu": {
"Educational requirement": int 100
}
"company": {
"worked at prefered company": float 4.1
}
"critical": {
"Node.js & Express.js Backend Development": int 1
"MongoDB & NoSQL Database Management": int 1
"RESTful API Design & Development": int 1
"JavaScript Proficiency (ES6+)": int 1
"Version Control (Git)": int 3
}
"essential": {
"Code Quality & Best Practices": int 1
"Performance Optimization": int 5
"Security Implementation": int 1
"Troubleshooting & Debugging": int 5
"Collaboration & Communication": int 5
}
"supporting": {
"Full MERN Stack Familiarity (React.js)": int 1
"Problem-Solving & Analytical Skills": int 5
"Continuous Learning & Staying Updated": int 1
}
"nicetohave": {
"CICD": int 5
}
}
"resume_insights": {
"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."
]
}
[1]: {
"parameter": string "MongoDB & NoSQL Database Management"
"rating": int 1
"explaination": string "The resume does not mention any experience with MongoDB or other NoSQL databases."
"evidence": [
[0]: string "No evidence was found in the resume to support this skill or competence."
]
}
[2]: {
"parameter": string "RESTful API Design & Development"
"rating": int 1
"explaination": string "The resume indicates experience integrating third-party APIs, but lacks evidence of designing or developing RESTful APIs themselves."
"evidence": [
[0]: string "Integrated third-party APIs for payments (Razorpay), delivery (Borzo), and SMS (Textlocal)"
]
}
[3]: {
"parameter": string "JavaScript Proficiency (ES6+)"
"rating": int 1
"explaination": string "The resume does not provide any evidence of JavaScript proficiency or its application in development."
"evidence": [
[0]: string "No evidence was found in the resume to support this skill or competence."
]
}
[4]: {
"parameter": string "Version Control (Git)"
"rating": int 3
"explaination": string "The candidate built a staging environment with version control for CI/CD, indicating practical experience with version control systems, likely Git, in a development workflow."
"evidence": [
[0]: string "Built a staging environment with version control for CI/CD, reducing deployment errors by 40% and accelerating release cycles."
]
}
]
"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."
]
}
[1]: {
"parameter": string "Performance Optimization"
"rating": int 5
"explaination": string "The candidate demonstrated significant impact on performance and efficiency through scaling operations, implementing microservices, and optimizing various processes with quantifiable results."
"evidence": [
[0]: string "Scaled city operations to 5,000+ active users and 250+ daily orders by building lean, reliable fulfillment systems."
[1]: string "Oversaw roadmap and timely delivery of 5+ microservices under resource constraints"
[2]: string "Implemented cluster-based order routing, optimising delivery routes and reducing logistics cost by 15%."
[3]: string "Automated pricing analysis, saving 2 hours/day"
[4]: string "Optimised Order-to-Cash MIS workflows, cutting manual effort by ~40 hours/month."
[5]: string "Automated report generation via SMTP integrations, reducing reporting turnaround time by 70%."
]
}
[2]: {
"parameter": string "Security Implementation"
"rating": int 1
"explaination": string "The resume does not provide any evidence or mention of security implementation practices or features."
"evidence": [
[0]: string "No evidence was found in the resume to support this skill or competence."
]
}
[3]: {
"parameter": string "Troubleshooting & Debugging"
"rating": int 5
"explaination": string "The candidate explicitly mentions implementing "RCA capabilities" and reducing "deployment errors," demonstrating strong analytical skills in diagnosing and resolving complex issues."
"evidence": [
[0]: string "Built a staging environment with version control for CI/CD, reducing deployment errors by 40%"
[1]: string "Launched an enterprise-level order management dashboard with RCA capabilities"
[2]: string "Identified $25M in billing leakage by analysing revenue projections, enabling corrective actions across finance operations."
]
}
[4]: {
"parameter": string "Collaboration & Communication"
"rating": int 5
"explaination": string "The candidate led a 15-member cross-functional team and collaborated extensively with various departments and stakeholders, demonstrating strong leadership and communication skills."
"evidence": [
[0]: string "Led a 15-member cross-functional team with developers, designers, and marketers to deliver product features on time using agile methodologies."
[1]: string "Collaborated with Corporate Finance to identify key business insights from large datasets"
]
}
]
"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."
]
}
[1]: {
"parameter": string "Problem-Solving & Analytical Skills"
"rating": int 5
"explaination": string "The resume provides numerous examples of identifying complex problems, analyzing data, and implementing innovative solutions with significant quantifiable impact."
"evidence": [
[0]: string "Identified $25M in billing leakage by analysing revenue projections"
[1]: string "Launched a Naïve Bayes model to predict win/loss of business opportunities"
[2]: string "Implemented cluster-based order routing, optimising delivery routes and reducing logistics cost by 15%."
[3]: string "Orchestrated a 25-day-long focused experimentation to boost avg site visit to app-install rate from 10% to 24%."
]
}
[2]: {
"parameter": string "Continuous Learning & Staying Updated"
"rating": int 1
"explaination": string "The resume does not explicitly mention any activities related to continuous technical learning, such as courses, certifications, or community involvement."
"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."
]
}
]
}
"rejection_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
{
"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": -d {
"critical": [
"{LIST_OF_CRITICALS}"
],
"essential": [
"{LIST_OF_ESSENTIALS}"
],
"supporting": [
"{LIST_OF_SUPPORTING}"
],
"nicetohave": [
"{LIST_OF_NICETOHAVE}"
]
}
}
"root": {
"sc_list": {
"critical": [
[0]: string "Skill"
]
"essential": [
[0]: string "Skill"
]
"supporting": [
[0]: string "Skill"
]
"nicetohave": [
[0]: string "Skill"
]
}
}