Convert a PDF or DOCX Resume to the JSON Resume Format

import json
import os
import sys
import time
from pathlib import Path
from urllib.parse import urlparse

import requests
from jsonschema import Draft7Validator, FormatChecker

API_URL = "https://hirelayer.co/api/v3/parser"
SCHEMA_URL = (
    "https://raw.githubusercontent.com/jsonresume/jsonresume.org"
    "/master/packages/schema/schema.json"
)


def parse_resume(path: Path, attempts: int = 4) -> dict:
    """POST the PDF or DOCX to CV Extract V3, retrying 5xx errors."""
    for attempt in range(1, attempts + 1):
        with path.open("rb") as handle:
            response = requests.post(
                API_URL,
                headers={"X-API-Key": os.environ["HIRELAYER_API_KEY"]},
                files={"file": (path.name, handle)},
                timeout=150,  # the API answers 504 after 145 s
            )
        if response.status_code == 200:
            return response.json()
        if response.status_code < 500 or attempt == attempts:
            request_id = response.headers.get("x-parser-request-id")
            raise RuntimeError(
                f"CV Extract {response.status_code} ({request_id}): {response.text[:300]}"
            )
        time.sleep(2**attempt)

def to_json_resume(parsed: dict) -> dict:
    """Map a CV Extract V3 response onto JSON Resume 1.7.0."""
    person, info = parsed["info_candidate"], parsed["info_resume"]
    loc = person["location"]
    skills: dict[str, list[str]] = {}
    for skill in parsed["skills"]:  # themes render skills grouped under a name
        skills.setdefault(skill["skill_type"], []).append(skill["skill_title"])
    return clean({
        "$schema": SCHEMA_URL,
        "basics": {
            "name": person["full_name"],
            "label": person["job_title"],
            # a face_url with an expiry (do_not_store_data=true) dies after 10 minutes
            "image": None if info["face_url_expires_at"] else info["face_url"],
            "email": person["email"], "phone": person["phone_number"],
            "url": as_url((person["other_urls"] or [None])[0]),
            "location": {"address": loc["full_address"], "postalCode": loc["postal_code"],
                         "city": loc["city"], "countryCode": loc["country_code"],
                         "region": loc["region"]},
            "profiles": [profile("LinkedIn", person["linkedin_url"]),
                         profile("GitHub", person["github_url"])],
        },
        "work": [{"name": job["company_name"], "position": job["job_title"],
                  "location": place(job["work_experience_city"],
                                    job["work_experience_country"]),
                  "startDate": job["start_date"], "summary": job["description"],
                  "endDate": None if job["currently_active"] else job["end_date"]}
                 for job in parsed["work_experiences"]],
        "education": [{"institution": edu["school_name"], "studyType": edu["degree_title"],
                       "startDate": edu["start_date"], "summary": edu["description"],
                       "endDate": None if edu["currently_active"] else edu["end_date"]}
                      for edu in parsed["educations"]],
        "skills": [{"name": name, "keywords": list(dict.fromkeys(words))}
                   for name, words in skills.items()],
        "languages": [{"language": lang["language"], "fluency": lang["level"]}
                      for lang in parsed["languages"]],
        "certificates": [{"name": name} for name in parsed["certifications"]],
        "interests": [{"name": name} for name in parsed["interests"]],
        "meta": {"lastModified": info["date_parsing"]},
    })

def clean(value):
    """Drop None and empty values, recursively: JSON Resume rejects null."""
    if isinstance(value, dict):
        value = {k: clean(v) for k, v in value.items()}
        return {k: v for k, v in value.items() if v not in (None, "", [], {})}
    if isinstance(value, list):
        return [v for v in map(clean, value) if v not in (None, "", [], {})]
    return value


def as_url(value: str | None) -> str | None:
    """Resumes write "github.com/name", but the schema wants a full URI."""
    return value if not value or "://" in value else f"https://{value}"


def place(city: str | None, country: str | None) -> str | None:
    return ", ".join(part for part in (city, country) if part) or None


def profile(network: str, url: str | None) -> dict | None:
    url = as_url(url)
    if url:
        username = urlparse(url).path.rstrip("/").split("/")[-1] or None
        return {"network": network, "username": username, "url": url}


def main() -> None:
    parsed = parse_resume(Path(sys.argv[1]))
    resume = to_json_resume(parsed)
    schema = requests.get(SCHEMA_URL, timeout=30).json()
    validator = Draft7Validator(schema, format_checker=FormatChecker())
    errors = [f"{e.json_path}: {e.message}" for e in validator.iter_errors(resume)]
    if errors:
        sys.exit("Invalid JSON Resume:\n" + "\n".join(errors))
    json.dump(resume, sys.stdout, indent=2, ensure_ascii=False)


if __name__ == "__main__":
    main()

python -m pip install requests "jsonschema[format-nongpl]"
export HIRELAYER_API_KEY="your-key-from-the-dashboard"
python to_json_resume.py resume.pdf > resume.json

npm install -g resume-cli
npm install jsonresume-theme-elegant
resume validate --resume resume.json
resume serve --resume resume.json --theme elegant
resume export resume.pdf --resume resume.json --theme elegant

{
  "basics": {
    "name": "Daniel OKAFOR",
    "label": "Senior Backend Engineer",
    "phone": "+447700900418",
    "profiles": [
      { "network": "GitHub", "username": "dokafor-dev", "url": "https://github.com/dokafor-dev" }
    ]
  },
  "work": [
    { "name": "Deliveroo", "position": "Senior Backend Engineer", "startDate": "2022-01-01" }
  ],
  "languages": [{ "language": "French", "fluency": "Limited Working Proficiency (B1)" }]
}