Log In Sign Up Free
Documentation

Getting Started with ResumeParser API

Welcome to the ResumeParser API documentation. Our cloud-based API extracts structured data from resume files in various formats using advanced statistical data and advanced AI models to parse resumes and return standardized JSON data.

To start using the API, you'll need to:

  1. Subscribe to the ResumeParser API on RapidAPI
  2. Obtain your RapidAPI key from the RapidAPI dashboard
  3. Make API calls using your preferred programming language

The ResumeParser API follows RESTful principles and returns responses in JSON format following a predefined schema.

⚠️
Keep your API keys secure

Your RapidAPI keys carry many privileges, so be sure to keep them secure. Don't share your API keys in publicly accessible areas such as GitHub, client-side code, or in API calls made directly from a browser.

Authentication

The ResumeParser API is hosted on RapidAPI and uses RapidAPI's authentication system. You'll need to include your RapidAPI key in the request headers.

Authentication is performed via RapidAPI headers:


X-RapidAPI-Key: YOUR_RAPIDAPI_KEY
X-RapidAPI-Host: resumeparser.p.rapidapi.com
                

All API requests must be made over HTTPS. Calls made over plain HTTP will fail. API requests without authentication will also fail.

API Endpoints

The ResumeParser API provides the following endpoints:

POST
/parse-resume

Alternative endpoints: /api/resume or /api/resume/

This endpoint extracts structured data from a resume file.

Request Parameters

Parameter Type Description
resume Required File The resume file to parse. Supported formats: PDF, DOCX, TXT, RTF

Request Details

  • Method: POST
  • Content-Type: multipart/form-data
  • Body: Form data with file upload

Response


{
  "contact": {
    "name": "John Smith",
    "email": "[email protected]",
    "phone": "+1 (555) 123-4567",
    "address": "San Francisco, CA 94105",
    "website": "https://johnsmith.com",
    "social": {
      "linkedin": "https://linkedin.com/in/johnsmith",
      "github": "https://github.com/johnsmith",
      "twitter": "https://twitter.com/johnsmith",
      "portfolio": "https://portfolio.johnsmith.com"
    }
  },
  "summary": "Experienced software engineer with 8+ years developing scalable web applications...",
  "education": [
    {
      "degree": "Master of Science in Computer Science",
      "institution": "Stanford University",
      "startDate": "2018-09-01",
      "endDate": "2020-06-15",
      "gpa": "3.8/4.0",
      "location": "Stanford, CA",
      "details": [
        "Specialization in Machine Learning",
        "Dean's List - All Semesters"
      ]
    }
  ],
  "experience": [
    {
      "title": "Senior Software Engineer",
      "company": "Tech Innovations Inc.",
      "location": "San Francisco, CA",
      "startDate": "2020-07-01",
      "endDate": null,
      "responsibilities": [
        "Led development of microservices architecture serving 1M+ users",
        "Reduced system latency by 40% through optimization",
        "Mentored team of 5 junior developers"
      ]
    }
  ],
  "projects": [
    {
      "name": "AI Resume Matcher",
      "description": "Built ML-powered resume matching system",
      "technologies": ["Python", "TensorFlow", "AWS"],
      "link": "https://github.com/johnsmith/resume-matcher"
    }
  ],
  "certifications": [
    {
      "name": "AWS Certified Solutions Architect",
      "issuer": "Amazon Web Services",
      "date": "2021-03-15",
      "credentialId": "AWS-123456",
      "link": "https://aws.amazon.com/verification/123456"
    }
  ],
  "skills": {
    "programmingLanguages": ["Python", "JavaScript", "Java", "Go"],
    "frameworks": ["React", "Django", "Spring Boot", "Express.js"],
    "tools": ["Docker", "Kubernetes", "Jenkins", "Git"],
    "databases": ["PostgreSQL", "MongoDB", "Redis", "MySQL"],
    "methodologies": ["Agile", "Scrum", "CI/CD", "TDD"],
    "other": ["System Design", "API Development", "Cloud Architecture"]
  },
  "languages": [
    {
      "name": "English",
      "proficiency": "native"
    },
    {
      "name": "Spanish",
      "proficiency": "fluent"
    }
  ],
  "awards": [
    {
      "title": "Best Innovation Award",
      "issuer": "Tech Innovations Inc.",
      "date": "2022-12-01",
      "description": "For developing the company's most successful product feature"
    }
  ],
  "hobbies": ["Open Source Contributing", "Technical Blogging", "Hiking"]
}
                        

{
  "error": "No resume file provided"
}
                        
GET
/api/resume/health

Check the health status of the resume parser service.

Response


{
  "service": "Resume Parser API",
  "status": "healthy",
  "timestamp": "2025-01-01T12:00:00.000Z",
  "supportedFileTypes": ["pdf"]
}
                
GET
/

Get general information about the API service.

Response


{
  "service": "Document Parser API",
  "version": "1.0.0",
  "endpoints": {
    "resume": {
      "parse": "POST /parse-resume OR POST /api/resume",
      "health": "GET /api/resume/health"
    }
  },
  "supportedFormats": {
    "resume": ["pdf"]
  },
  "timestamp": "2025-01-01T12:00:00.000Z"
}
                

Data Structure

The ResumeParser API returns a comprehensive JSON structure with the following fields:

Contact Information

  • name: Full name of the candidate
  • email: Email address (validated format)
  • phone: Phone number (validated format)
  • address: Physical address
  • website: Personal website URL
  • social: Social media profiles
    • linkedin
    • github
    • twitter
    • portfolio

Summary

Professional summary or objective statement from the resume.

Education

Array of education entries, each containing:

  • degree: Degree obtained or pursuing
  • institution: Name of educational institution
  • startDate: Start date (ISO 8601 format)
  • endDate: End date (ISO 8601 format)
  • gpa: Grade Point Average
  • location: Location of institution
  • details: Additional details or achievements

Experience

Array of work experience entries, each containing:

  • title: Job title
  • company: Company name
  • location: Job location
  • startDate: Start date (ISO 8601 format)
  • endDate: End date (ISO 8601 format, null for current position)
  • responsibilities: List of job responsibilities and achievements

Projects

Array of project entries, each containing:

  • name: Project name
  • description: Project description
  • technologies: List of technologies used
  • link: Project URL

Certifications

Array of certification entries, each containing:

  • name: Certification name
  • issuer: Issuing organization
  • date: Date obtained (ISO 8601 format)
  • credentialId: Credential ID
  • link: Verification URL

Skills

Categorized skills object containing:

  • programmingLanguages: Programming languages
  • frameworks: Frameworks and libraries
  • tools: Development tools
  • databases: Database technologies
  • methodologies: Development methodologies
  • other: Other relevant skills

Languages

Array of language entries, each containing:

  • name: Language name
  • proficiency: native | fluent | proficient | conversational | basic

Awards

Array of award entries, each containing:

  • title: Award title
  • issuer: Issuing organization
  • date: Date received (ISO 8601 format)
  • description: Award description

Hobbies

Array of strings listing personal interests and hobbies.

Response Codes

The ResumeParser API uses conventional HTTP response codes to indicate the success or failure of an API request:

Code Description
200 - OK The request was successful.
400 - Bad Request The request was invalid. Common causes: missing file, wrong content type, unsupported file format.
405 - Method Not Allowed The HTTP method used is not allowed for this endpoint.
500 - Internal Server Error An error occurred on the server. This could be due to server configuration issues or processing errors.

Rate Limits

Rate limiting is handled at the API level and through RapidAPI. Specific limits depend on your RapidAPI subscription plan.

Rate limit information is included in the RapidAPI response headers:

X-RateLimit-Limit: [depends on plan] X-RateLimit-Remaining: [requests remaining] X-RateLimit-Reset: [reset timestamp]

Contact RapidAPI support for information about rate limits for your specific plan.

Error Handling

The API returns appropriate HTTP status codes and error messages in JSON format.

Common Error Responses

400 Bad Request

{ "error": "Request must be multipart/form-data" }
{ "error": "No resume file provided" }
{ "error": "Unsupported file type: .xyz" }

405 Method Not Allowed

{ "error": "Method not allowed" }

500 Internal Server Error

{ "error": "Could not establish server connection" }

Error Handling Best Practices

  • Always check the HTTP status code before processing the response
  • Implement proper error handling for network issues
  • Validate file type and size on the client side before sending
  • Display user-friendly error messages based on the error response

Code Examples

Here are examples showing how to use the ResumeParser API in different programming languages:

Code Examples

Here are examples showing how to use the ResumeParser API in different programming languages:

JavaScript (Browser)


const formData = new FormData();
formData.append('resume', fileInput.files[0]);

const response = await fetch('https://resumeparser.p.rapidapi.com/api/resume', {
  method: 'POST',
  headers: {
    'X-RapidAPI-Key': 'YOUR_RAPIDAPI_KEY',
    'X-RapidAPI-Host': 'resumeparser.p.rapidapi.com'
  },
  body: formData
});

if (!response.ok) {
  const error = await response.json();
  throw new Error(error.error || `API error: ${response.status}`);
}

const data = await response.json();
console.log('Parsed resume:', data);
    

Node.js


const FormData = require('form-data');
const fs = require('fs');
const axios = require('axios');

async function parseResume(filePath) {
    const form = new FormData();
    form.append('resume', fs.createReadStream(filePath));
    
    try {
        const response = await axios.post(
            'https://resumeparser.p.rapidapi.com/api/resume',
            form,
            {
                headers: {
                    ...form.getHeaders(),
                    'X-RapidAPI-Key': 'YOUR_RAPIDAPI_KEY',
                    'X-RapidAPI-Host': 'resumeparser.p.rapidapi.com'
                }
            }
        );
        
        return response.data;
    } catch (error) {
        console.error('Error parsing resume:', error.response?.data || error.message);
        throw error;
    }
}

// Usage
parseResume('./resume.pdf')
    .then(data => console.log(JSON.stringify(data, null, 2)))
    .catch(error => console.error(error));
    

Python


import requests
import json

def parse_resume(file_path):
    url = "https://resumeparser.p.rapidapi.com/api/resume"
    
    headers = {
        "X-RapidAPI-Key": "YOUR_RAPIDAPI_KEY",
        "X-RapidAPI-Host": "resumeparser.p.rapidapi.com"
    }
    
    with open(file_path, 'rb') as f:
        files = {'resume': f}
        response = requests.post(url, headers=headers, files=files)
    
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"Error: {response.status_code} - {response.text}")

# Usage
try:
    result = parse_resume('resume.pdf')
    print(json.dumps(result, indent=2))
except Exception as e:
    print(f"Error parsing resume: {e}")
    

HTML Form Example


<!DOCTYPE html>
<html>
<head>
    <title>Resume Parser</title>
</head>
<body>
    <form id="resumeForm">
        <input type="file" id="resumeFile" accept=".pdf,.docx,.txt,.rtf" required>
        <button type="submit">Parse Resume</button>
    </form>
    <pre id="result"></pre>
    
    <script>
        document.getElementById('resumeForm').addEventListener('submit', async (e) => {
            e.preventDefault();
            
            const fileInput = document.getElementById('resumeFile');
            const formData = new FormData();
            formData.append('resume', fileInput.files[0]);
            
            try {
                const response = await fetch('https://resumeparser.p.rapidapi.com/api/resume', {
                    method: 'POST',
                    headers: {
                        'X-RapidAPI-Key': 'YOUR_RAPIDAPI_KEY',
                        'X-RapidAPI-Host': 'resumeparser.p.rapidapi.com'
                    },
                    body: formData
                });
                
                const data = await response.json();
                document.getElementById('result').textContent = JSON.stringify(data, null, 2);
            } catch (error) {
                document.getElementById('result').textContent = 'Error: ' + error.message;
            }
        });
    </script>
</body>
</html>
  

Frequently Asked Questions

How do I get started with the API?
Subscribe to the ResumeParser API on RapidAPI, get your API key, and you can start making requests immediately. Check out our code examples to get started quickly.
What file formats are supported?
We support PDF, DOCX, TXT, and RTF file formats. The API automatically detects the file type and uses the appropriate parser.
Is there a file size limit?
Files under 10MB are processed optimally. We can handle files up to 20MB, but larger files may take longer to process.
How accurate is the parsing?
Our API uses advanced statistical data and advanced AI models to achieve high accuracy. The structured output follows a consistent schema, making it easy to integrate into your applications.
Can I parse multiple resumes at once?
Currently, the API processes one resume per request. For bulk processing, you'll need to make multiple API calls.
What happens if the API can't parse certain information?
The API returns all fields in the schema. Fields that couldn't be extracted will be returned as null or empty arrays/objects as appropriate.
Is CORS supported for browser-based applications?
Yes, the API includes CORS headers to support cross-origin requests from browser-based applications.
How do I handle errors?
The API returns appropriate HTTP status codes and error messages in JSON format. Always check the status code and implement proper error handling in your application.