Resume Parser API

curl -X POST \
  -F "file=@resume.pdf" \
  https://resume.codekrafters.co.in/api/upload-resume

const form = new FormData();
form.append("file", pdfFile);        // File from <input type="file">

const res = await fetch("/api/upload-resume", {
  method: "POST",
  body: form,
});
const json = await res.json();

// JSON Resume schema response
const uploadId = json.upload_id;
const basics = json.data.basics;
const summary = json.data.basics.summary;
const work = json.data.work;
console.log(basics.name, basics.email);

import * as DocumentPicker from "expo-document-picker";

// 1. Pick the PDF
const pick = await DocumentPicker.getDocumentAsync({
  type: "application/pdf",
});
if (pick.canceled) return;
const file = pick.assets[0];

// 2. Upload
const formData = new FormData();
formData.append("file", {
  uri: file.uri,
  name: file.name,
  type: "application/pdf",
});

const res = await fetch("http://192.168.1.10:3000/api/upload-resume", {
  method: "POST",
  body: formData,
  headers: { "Content-Type": "multipart/form-data" },
});
const json = await res.json();
// Save upload_id for later template rendering
await AsyncStorage.setItem("upload_id", String(json.upload_id));

import axios from "axios";

const form = new FormData();
form.append("file", file);

const { data } = await axios.post(
  "/api/upload-resume",
  form,
  { headers: { "Content-Type": "multipart/form-data" } }
);
console.log(data.upload_id, data.data.basics, data.ats_scores);

{
  "status": 200,
  "statusText": "OK",
  "message": "Resume uploaded and parsed successfully",
  "upload_id": 18,
  "resume_file": "resume_JOHN-DOE_18_1776874753.pdf",
  "schema": "jsonresume",
  "data": {
    "basics": {
      "name": "John Doe",
      "label": "Programmer",
      "image": "",
      "email": "john@gmail.com",
      "phone": "(912) 555-4321",
      "url": "https://johndoe.com",
      "summary": "A summary of John Doe…",
      "location": {
        "address": "2712 Broadway St",
        "postalCode": "CA 94115",
        "city": "San Francisco",
        "countryCode": "US",
        "region": "California"
      },
      "profiles": [{
        "network": "Twitter",
        "username": "john",
        "url": "https://twitter.com/john"
      }]
    },
    "work": [{
      "name": "Company",
      "position": "President",
      "url": "https://company.com",
      "startDate": "2013-01-01",
      "endDate": "2014-01-01",
      "summary": "Description…",
      "highlights": ["Started the company"]
    }],
    "education": [{
      "institution": "University",
      "url": "https://institution.com/",
      "area": "Software Development",
      "studyType": "Bachelor",
      "startDate": "2011-01-01",
      "endDate": "2013-01-01",
      "score": "4.0",
      "courses": ["DB1101 - Basic SQL"]
    }],
    "skills": [{
      "name": "Web Development",
      "level": "Master",
      "keywords": ["HTML", "CSS", "JavaScript"]
    }],
    "projects": [{
      "name": "Project",
      "startDate": "2019-01-01",
      "endDate": "2021-01-01",
      "description": "Description...",
      "highlights": ["Won award at AIHacks 2016"],
      "url": "https://project.com/"
    }],
    "certificates": [{
      "name": "Certificate",
      "date": "2021-11-07",
      "issuer": "Company",
      "url": "https://certificate.com"
    }],
    "awards": [{
      "title": "Award",
      "date": "2014-11-01",
      "awarder": "Company",
      "summary": "There is no spoon."
    }],
    "publications": [{
      "name": "Publication",
      "publisher": "Company",
      "releaseDate": "2014-10-01",
      "url": "https://publication.com",
      "summary": "Description…"
    }],
    "languages": [{
      "language": "English",
      "fluency": "Native speaker"
    }],
    "interests": [{
      "name": "Wildlife",
      "keywords": ["Ferrets", "Unicorns"]
    }],
    "references": [{
      "name": "Jane Doe",
      "reference": "Reference…"
    }],
    "volunteer": [{
      "organization": "Organization",
      "position": "Volunteer",
      "url": "https://organization.com/",
      "startDate": "2012-01-01",
      "endDate": "2013-01-01",
      "summary": "Description…",
      "highlights": ["Awarded 'Volunteer of the Month'"]
    }]
  },
  "ats_scores": {
    "overall_score": 75,
    "breakdown": {
      "contact_info": 80,
      "work_experience": 75,
      "education": 80,
      "skills": 70
    },
    "feedback": [
      "Add more quantitative achievements to your work experience.",
      "Consider adding links to your projects."
    ]
  }
}

curl https://resume.codekrafters.co.in/api/resume/18

const res = await fetch(`/api/resume/${uploadId}`);
const { data, ats_scores } = await res.json();

{
  "status": 200,
  "statusText": "OK",
  "message": "Resume fetched successfully",
  "upload_id": 18,
  "resume_file": "resume_JOHN-DOE_18_1776874753.pdf",
  "schema": "jsonresume",
  "data": {
    "basics": {...},
    "work": [...],
    "education": [...],
    "skills": [...],
    "projects": [...],
    "certificates": [...],
    "awards": [...],
    "publications": [...],
    "languages": [...],
    "interests": [...],
    "references": [...],
    "volunteer": [...]
  },
  "ats_scores": {
    "overall_score": 75,
    "breakdown": { "contact_info": 80, "work_experience": 75, "education": 80, "skills": 70 },
    "feedback": [
      "Add more quantitative achievements to your work experience.",
      "Consider adding links to your projects."
    ]
  }
}

{
  "status": 200,
  "statusText": "OK",
  "message": "JSON Resume fetched successfully",
  "schema": "jsonresume",
  "spec_url": "https://jsonresume.org/schema",
  "upload_id": 18,
  "data": { "basics": {...}, "work": [...], "education": [...], "skills": [...] }
}

curl https://resume.codekrafters.co.in/api/jsonresume/18

curl "https://resume.codekrafters.co.in/api/templates?category=modern&limit=5"

{
  "status": 200,
  "statusText": "OK",
  "message": "Templates fetched successfully",
  "data": {
    "total": 62,
    "page": 1,
    "limit": 10,
    "pages": 7,
    "templates": [
      {
        "id": 1,
        "slug": "minimalist-clean",
        "name": "The Minimalist",
        "description": "Clean, structured layout with emphasis on typography.",
        "category": "modern",
        "thumbnail": "https://resume.codekrafters.co.in/static/templates/thumb/1.png",
        "color_scheme": {
          "primary": "#2c3e50",
          "secondary": "#f7f9fa",
          "text": "#333333",
          "accent": "#2c3e50"
        },
        "font_family": "Inter, sans-serif",
        "layout": "two_column",
        "is_premium": false,
        "template_file": "resume_1_minimalist.html",
        "sections": ["summary", "experience", "education", "skills"],
        "tags": ["minimal", "corporate", "ats-friendly"],
        "render_url": "https://resume.codekrafters.co.in/api/templates/1/render",
        "preview_url": "https://resume.codekrafters.co.in/api/templates/1/preview"
      }
    ]
  }
}

curl https://resume.codekrafters.co.in/api/templates/3

{
  "status": 200,
  "data": {
    "id": 3,
    "slug": "dark-mode-dev",
    "name": "Dark Mode Dev",
    "category": "modern",
    "layout": "two_column",
    "is_premium": false,
    "tags": ["developer", "dark", "tech", "engineering"],
    "render_url":  "https://resume.codekrafters.co.in/api/templates/3/render",
    "preview_url": "https://resume.codekrafters.co.in/api/templates/3/preview"
  }
}

curl https://resume.codekrafters.co.in/api/templates/categories

{
  "status": 200,
  "data": {
    "total": 3,
    "categories": [
      { "name": "modern",   "count": 28 },
      { "name": "classic",  "count": 19 },
      { "name": "creative", "count": 15 }
    ]
  }
}

{
  "basics": {
    "name": "Poonam Batham",
    "email": "poonam@example.com",
    "phone": "+91-9399435171",
    "label": "Python Backend Developer",
    "summary": "Python Backend Developer with 3 years..."
  },
  "work": [
    {
      "name": "SummitCode",
      "position": "Agentic AI Engineer",
      "startDate": "2026-01-01",
      "endDate": "",
      "summary": "",
      "highlights": ["Built AI agents", "Integrated LLMs"]
    }
  ],
  "education": [
    {
      "institution": "ITM University",
      "studyType": "B.E.",
      "area": "Computer Science",
      "endDate": "2018-06-01"
    }
  ],
  "projects": [
    {
      "name": "Order Management System",
      "description": "Backend with Flask + RBAC",
      "highlights": ["Flask", "MySQL"]
    }
  ],
  "skills": [
    { "name": "Backend", "keywords": ["Python", "Django", "Flask"] }
  ],
  "certificates": [
    {
      "name": "AWS Certified",
      "issuer": "Amazon Web Services",
      "date": "2024-08-01"
    }
  ]
}

{ "upload_id": 18 }

"use client";
import { useState, useEffect } from "react";

function useDebounce(value, delay = 400) {
  const [debounced, setDebounced] = useState(value);
  useEffect(() => {
    const t = setTimeout(() => setDebounced(value), delay);
    return () => clearTimeout(t);
  }, [value, delay]);
  return debounced;
}

export default function ResumeBuilder() {
  const [templateId, setTemplateId] = useState(1);
  const [resume, setResume] = useState({
    basics: { name: "", email: "" },
    work: [],
    education: [],
    projects: [],
    skills: [],
    certificates: [],
  });

  const debounced = useDebounce(resume, 400);
  const [html, setHtml] = useState("");

  useEffect(() => {
    fetch(`/api/templates/${templateId}/html`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(debounced),
    })
      .then((r) => r.text())
      .then(setHtml);
  }, [debounced, templateId]);

  return (
    <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr" }}>
      <Form data={resume} onChange={setResume} />
      <iframe srcDoc={html} style={{ width: "100%", height: "100vh", border: 0 }} />
    </div>
  );
}

import { WebView } from "react-native-webview";

const [html, setHtml] = useState("");

useEffect(() => {
  const timer = setTimeout(async () => {
    const res = await fetch(`${API}/api/templates/${id}/html`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(resume),
    });
    setHtml(await res.text());
  }, 400);
  return () => clearTimeout(timer);
}, [resume, id]);

<WebView source={{ html }} style={{ flex: 1 }} />

{
  "status": 200,
  "statusText": "OK",
  "message": "Template rendered successfully",
  "data": {
    "template_id": 3,
    "template_name": "Dark Mode Dev",
    "html": "<!DOCTYPE html><html>...</html>"
  }
}

curl -X POST https://resume.codekrafters.co.in/api/templates/3/render \
  -H "Content-Type: application/json" \
  -d '{"upload_id": 18}'

const res = await fetch(`/api/templates/${id}/render`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(resume),
});
const { data } = await res.json();
document.getElementById("preview").srcdoc = data.html;

# Sample data (for template thumbnails)
https://resume.codekrafters.co.in/api/templates/1/preview

# Real user data
https://resume.codekrafters.co.in/api/templates/3/preview?upload_id=18

<iframe
  src={`/api/templates/${id}/preview?upload_id=${uploadId}`}
  style={{ width: "100%", height: "100vh", border: 0 }}
/>

<WebView
  source={{ uri: `${API}/api/templates/${templateId}/preview?upload_id=${uploadId}` }}
  style={{ flex: 1 }}
/>

curl -X POST https://resume.codekrafters.co.in/api/ats-analyze \
  -H "Content-Type: application/json" \
  -d '{"resume": {"basics": {"name": "Jane Doe", "email": "jane@example.com"}, "work": [], "education": []}}'

curl -X POST https://resume.codekrafters.co.in/api/ats-analyze \
  -H "Content-Type: application/json" \
  -d '{"upload_id": 18}'

const res = await fetch("/api/ats-analyze", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ resume }),
});
const { rule_based, ai_analysis } = await res.json();

{
  "status": 200,
  "statusText": "OK",
  "rule_based": {
    "overall_score": 82,
    "breakdown": {
      "contact_info": 100,
      "work_experience": 80,
      "education": 90,
      "skills": 70
    },
    "feedback": [
      "Strong contact section.",
      "Add metrics to work bullets."
    ],
    "stats": {
      "word_count": 412,
      "bullet_count": 18,
      "quantified_bullets": 7,
      "action_verb_bullets": 14
    }
  },
  "ai_analysis": {
    "missing_sections": ["projects"],
    "weak_areas": [
      "Summary is too long",
      "Skills section lacks proficiency levels"
    ],
    "keyword_suggestions": ["TypeScript", "CI/CD", "Kubernetes"],
    "action_verb_upgrades": [
      { "from": "Worked on", "to": "Engineered" },
      { "from": "Helped with", "to": "Led" }
    ],
    "quantification_tips": [
      "Quantify the impact of your design system rebuild (e.g., reduced bundle size by X%)"
    ],
    "summary_rewrite": "Senior frontend engineer with 8+ years building production React apps...",
    "strengths": [
      "Quantified impact in last role",
      "Clear progression"
    ],
    "ats_risk_flags": [
      "References line still present",
      "Two-column layout may confuse some ATS parsers"
    ],
    "overall_recommendation": "Cut the summary, add metrics to 3 more bullets, and remove the references line.",
    "inferred_target_role": "Senior Frontend Engineer",
    "ai_powered": true
  }
}

{
  "status": 400,
  "statusText": "Bad Request",
  "message": "Human-readable message",
  "error_code": "ERROR_CODE",
  "data": null
}

async function safeFetch(url, init) {
  const res = await fetch(url, init);
  if (!res.ok) {
    let body;
    try { body = await res.json(); } catch { body = {}; }
    const code = body.error_code || res.status;
    const message = body.message || res.statusText;
    throw new Error(`[${code}] ${message}`);
  }
  return res.json();
}

"use client";
import { useState, useEffect } from "react";

const API = "";  // same-origin

export default function ResumeApp() {
  const [templates, setTemplates] = useState([]);
  const [uploadId, setUploadId] = useState(null);
  const [parsed, setParsed] = useState(null);
  const [selected, setSelected] = useState(1);
  const [html, setHtml] = useState("");
  const [ats, setAts] = useState(null);

  // 1) Load templates on mount
  useEffect(() => {
    fetch(`${API}/api/templates`)
      .then((r) => r.json())
      .then((j) => setTemplates(j.data.templates));
  }, []);

  // 2) Handle PDF upload
  const handleUpload = async (e) => {
    const file = e.target.files[0];
    if (!file) return;

    const form = new FormData();
    form.append("file", file);

    const res = await fetch(`${API}/api/upload-resume`, {
      method: "POST",
      body: form,
    });
    const j = await res.json();

    if (j.status !== 200) {
      alert(j.message);
      return;
    }
    setUploadId(j.upload_id);
    setParsed(j.data);
    setAts(j.ats_scores);  // initial rule-based scores
  };

  // 3) Re-render whenever template or data changes
  useEffect(() => {
    if (!parsed) return;
    fetch(`${API}/api/templates/${selected}/html`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(parsed),
    })
      .then((r) => r.text())
      .then(setHtml);
  }, [selected, parsed]);

  // 4) Get full AI feedback on demand
  const runAtsAnalysis = async () => {
    const res = await fetch(`${API}/api/ats-analyze`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ upload_id: uploadId }),
    });
    setAts(await res.json());
  };

  return (
    <div style={{ display: "grid", gridTemplateColumns: "1fr 2fr", gap: 16 }}>
      <aside>
        <input type="file" accept=".pdf" onChange={handleUpload} />
        <button onClick={runAtsAnalysis} disabled={!uploadId}>
          Run ATS Analysis
        </button>

        <h3>Pick a template</h3>
        <div style={{ display: "grid", gridTemplateColumns: "repeat(3, 1fr)", gap: 8 }}>
          {templates.map((t) => (
            <button key={t.id} onClick={() => setSelected(t.id)}>
              <img src={t.thumbnail} alt={t.name} style={{ width: "100%" }} />
              <div>{t.name}</div>
            </button>
          ))}
        </div>

        {ats?.rule_based && (
          <div>
            <h4>ATS score: {ats.rule_based.overall_score}/100</h4>
            <ul>
              {ats.rule_based.feedback.map((f, i) => <li key={i}>{f}</li>)}
            </ul>
          </div>
        )}
      </aside>

      <iframe srcDoc={html} style={{ width: "100%", height: "100vh", border: 0 }} />
    </div>
  );
}

import React, { useState, useEffect } from "react";
import { View, FlatList, Image, TouchableOpacity, Text, ScrollView } from "react-native";
import { WebView } from "react-native-webview";
import * as DocumentPicker from "expo-document-picker";

const API = "http://192.168.1.10:3000";

export default function ResumeScreen() {
  const [templates, setTemplates] = useState([]);
  const [uploadId, setUploadId] = useState(null);
  const [parsed, setParsed] = useState(null);
  const [selected, setSelected] = useState(null);
  const [ats, setAts] = useState(null);

  // 1) Load templates
  useEffect(() => {
    fetch(`${API}/api/templates`)
      .then((r) => r.json())
      .then((j) => setTemplates(j.data.templates));
  }, []);

  // 2) Pick + upload PDF
  const pickAndUpload = async () => {
    const res = await DocumentPicker.getDocumentAsync({ type: "application/pdf" });
    if (res.canceled) return;
    const file = res.assets[0];

    const form = new FormData();
    form.append("file", { uri: file.uri, name: file.name, type: "application/pdf" });

    const r = await fetch(`${API}/api/upload-resume`, {
      method: "POST",
      body: form,
      headers: { "Content-Type": "multipart/form-data" },
    });
    const j = await r.json();
    setUploadId(j.upload_id);
    setParsed(j.data);
    setAts(j.ats_scores);
  };

  // 3) Run full AI ATS analysis
  const runAts = async () => {
    const r = await fetch(`${API}/api/ats-analyze`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ upload_id: uploadId }),
    });
    setAts(await r.json());
  };

  // 4) Render template in a WebView
  if (selected && uploadId) {
    return (
      <WebView
        source={{ uri: `${API}/api/templates/${selected}/preview?upload_id=${uploadId}` }}
        style={{ flex: 1 }}
      />
    );
  }

  return (
    <ScrollView style={{ flex: 1 }}>
      <TouchableOpacity onPress={pickAndUpload}>
        <Text>Upload Resume PDF</Text>
      </TouchableOpacity>

      <TouchableOpacity onPress={runAts} disabled={!uploadId}>
        <Text>Run ATS Analysis</Text>
      </TouchableOpacity>

      {ats?.rule_based && (
        <View>
          <Text>Score: {ats.rule_based.overall_score}/100</Text>
        </View>
      )}

      <FlatList
        data={templates}
        numColumns={2}
        keyExtractor={(t) => String(t.id)}
        renderItem={({ item }) => (
          <TouchableOpacity onPress={() => setSelected(item.id)}>
            <Image source={{ uri: item.thumbnail }} style={{ width: 150, height: 200 }} />
            <Text>{item.name}</Text>
          </TouchableOpacity>
        )}
      />
    </ScrollView>
  );
}

// File in → parsed JSON + rendered HTML + ATS feedback out
async function runFullPipeline(file, templateId = 1) {
  // 1. Upload
  const form = new FormData();
  form.append("file", file);
  const upload = await fetch("/api/upload-resume", { method: "POST", body: form }).then(r => r.json());

  // 2. Render + ATS in parallel
  const [html, ats] = await Promise.all([
    fetch(`/api/templates/${templateId}/html`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(upload.data),
    }).then((r) => r.text()),
    fetch("/api/ats-analyze", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ upload_id: upload.upload_id }),
    }).then((r) => r.json()),
  ]);

  return { upload_id: upload.upload_id, data: upload.data, html, ats };
}