Schema Resume

A comprehensive, self-hosted JSON-LD schema for CV/Resume parsing and validation. This schema provides a standardized format for representing professional resumes in JSON format with semantic web integration, making it easy to parse, validate, and exchange resume data between systems without relying on external schema definitions.

• Comprehensive Coverage: Supports all standard resume sections including work experience, education, skills, certifications, publications, and more
• Flexible Date Format: ISO 8601 date format with optional precision (year, year-month, or full date)
• Extensible: Additional properties allowed for custom fields
• Well-Documented: Detailed descriptions and examples for all fields
• Self-Hosted: Complete validation without external dependencies
• JSON-LD Compatible: Semantic web integration with Schema.org mapping
• GitHub Pages Hosted: Publicly accessible schema URL for validation

The schema includes the following main sections:

• basics: Personal information, contact details, social profiles, nationalities, and work authorization
• work: Work experience and employment history
• volunteer: Volunteer work and community involvement
• education: Academic background and qualifications
• awards: Professional awards and recognitions
• certificates: Professional certifications
• publications: Published works and articles
• skills: Technical and professional skills with experience levels
• tools: Specific software and tools used professionally
• languages: Language proficiencies
• interests: Personal interests and hobbies
• references: Professional references
• projects: Personal and professional projects
• meta: Schema metadata and versioning

The schema and related files are hosted at https://schema-resume.org/:

• Main Schema: https://schema-resume.org/schema.json
• Meta Schema: https://schema-resume.org/meta-schema.json
• JSON-LD Context: https://schema-resume.org/context.jsonld

• XSD Schema: https://schema-resume.org/xml/1.0/schema-resume.xsd
• XML Example: https://schema-resume.org/xml/1.0/example.xml

Note: The schema is also available at the alternate domain https://tradik.github.io/schema-resume/ for backward compatibility.

The schema is self-contained and does not rely on external JSON Schema definitions.

Try the live validator: validator.html

The online validator provides:

• Real-time validation against Schema Resume v1.1.0
• JSON-LD compatibility checks for @context and Schema.org mapping
• Detailed error messages with suggestions for fixes
• Example CV to get started quickly
• JSON formatting tool
• Statistics about your CV content

Simply paste your JSON-LD CV and click "Validate" to check for errors and warnings.

Try the live converter: converter.html

The converter tool provides:

• Real-time conversion from JSON to JSON-LD or XML format
• Dual-panel editor with live updates as you type
• Remote or inline context - choose between URL reference or embedded context
• JSON-LD output with Schema.org context integration
• XML output with proper structure and escaping
• Validation with error reporting and suggestions
• Statistics including character and line counts
• Copy to clipboard for easy export
• Load example to see the format in action

Perfect for converting existing JSON resumes to semantic web formats or generating XML for legacy systems.

⚠️ Important for Schema.org Validation: If you plan to validate your resume with validator.schema.org, you must include @type properties for all structured entities (basics, location, profiles, nationalities, work, volunteer, education, awards, certificates, publications, skills, tools, projects, languages, interests, references). Also use streetAddress instead of address in location. See SCHEMA-ORG-VALIDATION.md for complete details. The @type field is optional for standard JSON Schema validation.

Create a JSON file with your resume data and reference the schema:

{
  "@context": "https://schema-resume.org/schema.json",
  "$schema": "https://schema-resume.org/schema.json",
  "basics": {
    "name": "John Doe",
    "label": "Software Engineer",
    "email": "john.doe@example.com",
    "phone": "+1-555-123-4567",
    "url": "https://johndoe.dev",
    "summary": "Experienced software engineer with 10+ years in full-stack development.",
    "location": {
      "city": "San Francisco",
      "countryCode": "US",
      "region": "California"
    },
    "profiles": [
      {
        "network": "LinkedIn",
        "username": "johndoe",
        "url": "https://linkedin.com/in/johndoe"
      }
    ]
  },
  "work": [
    {
      "name": "Tech Corp",
      "industry": "Information Technology",
      "location": {
        "city": "San Francisco",
        "region": "California",
        "countryCode": "US"
      },
      "contactDetails": {
        "email": "careers@techcorp.com",
        "phone": "+1-555-987-6543"
      },
      "position": "Senior Software Engineer",
      "startDate": "2020-03",
      "summary": "Lead development of microservices architecture",
      "highlights": [
        "Reduced API response time by 40%",
        "Mentored team of 5 junior developers"
      ]
    }
  ],
  "skills": [
    {
      "name": "Backend Development",
      "level": "Expert",
      "keywords": ["Node.js", "Python", "PostgreSQL"]
    }
  ]
}

See example.json for a complete JSON example.

Create an XML file with your resume data and reference the XSD schema:

<?xml version="1.0" encoding="UTF-8"?>
<resume xmlns="https://schema-resume.org/xml/1.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="https://schema-resume.org/xml/1.0
                            https://schema-resume.org/xml/1.0/schema-resume.xsd">
  
  <basics>
    <name>John Doe</name>
    <label>Software Engineer</label>
    <email>john.doe@example.com</email>
    <phone>+1-555-123-4567</phone>
    <url>https://johndoe.dev</url>
    <summary>Experienced software engineer with 10+ years in full-stack development.</summary>
    
    <location>
      <city>San Francisco</city>
      <countryCode>US</countryCode>
      <region>California</region>
    </location>
    
    <profiles>
      <profile>
        <network>LinkedIn</network>
        <username>johndoe</username>
        <url>https://linkedin.com/in/johndoe</url>
      </profile>
    </profiles>
  </basics>
  
  <work>
    <name>Tech Corp</name>
    <industry>Information Technology</industry>
    <location>
      <city>San Francisco</city>
      <region>California</region>
      <countryCode>US</countryCode>
    </location>
    <contactDetails>
      <email>careers@techcorp.com</email>
      <phone>+1-555-987-6543</phone>
    </contactDetails>
    <position>Senior Software Engineer</position>
    <startDate>2020-03</startDate>
    <summary>Lead development of microservices architecture</summary>
    <highlights>
      <item>Reduced API response time by 40%</item>
      <item>Mentored team of 5 junior developers</item>
    </highlights>
  </work>
  
  <skills>
    <name>Backend Development</name>
    <level>Expert</level>
    <keywords>
      <item>Node.js</item>
      <item>Python</item>
      <item>PostgreSQL</item>
    </keywords>
  </skills>
  
</resume>

See xml/1.0/example.xml for a complete XML example.

You can validate your resume JSON against this schema using various tools:

# Install AJV CLI globally
npm install -g ajv-cli ajv-formats

# Validate against local schema
ajv validate -s schema.json -d your-resume.json --strict=false

# Validate against hosted schema
ajv validate -s https://schema-resume.org/schema.json -d your-resume.json --strict=false

import json
import jsonschema
import requests

# Load schema
schema_url = "https://schema-resume.org/schema.json"
schema = requests.get(schema_url).json()

# Load your resume
with open('your-resume.json') as f:
    resume = json.load(f)

# Validate
jsonschema.validate(instance=resume, schema=schema)
print("Resume is valid!")

• Schema Resume Validator - Recommended, specifically designed for this schema
• JSON Schema Validator
• JSON Schema Lint

You can validate your XML resume against the XSD schema using various tools:

Using xmllint (Linux/Mac):

# Validate against local XSD
xmllint --schema xml/1.0/schema-resume.xsd your-resume.xml --noout

# Validate against hosted XSD
xmllint --schema https://schema-resume.org/xml/1.0/schema-resume.xsd your-resume.xml --noout

Using Python:

from lxml import etree
import requests

# Load XSD schema
xsd_url = "https://schema-resume.org/xml/1.0/schema-resume.xsd"
xsd_doc = etree.parse(requests.get(xsd_url, stream=True).raw)
xsd_schema = etree.XMLSchema(xsd_doc)

# Load and validate XML
xml_doc = etree.parse('your-resume.xml')
if xsd_schema.validate(xml_doc):
    print("XML is valid!")
else:
    print("Validation errors:", xsd_schema.error_log)

Using Java:

import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.*;
import java.io.File;
import java.net.URL;

public class ResumeValidator {
    public static void main(String[] args) throws Exception {
        SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        Schema schema = factory.newSchema(
            new URL("https://schema-resume.org/xml/1.0/schema-resume.xsd")
        );
        
        Validator validator = schema.newValidator();
        validator.validate(new StreamSource(new File("your-resume.xml")));
        System.out.println("XML is valid!");
    }
}

Using Online XML Validators:

• FreeFormatter XML Validator
• XML Validation

For complete field descriptions, see the schema.json file.

Dates follow ISO 8601 format with flexible precision:

• Full date: 2024-03-15
• Year and month: 2024-03
• Year only: 2024

This allows representing dates when exact day or month is not relevant.

import Ajv from 'ajv';
import schema from './schema.json';

const ajv = new Ajv();
const validate = ajv.compile(schema);

const resume = {
  // Your resume data
};

if (validate(resume)) {
  console.log('Resume is valid!');
} else {
  console.error('Validation errors:', validate.errors);
}

import json
from jsonschema import validate, ValidationError

with open('schema.json') as schema_file:
    schema = json.load(schema_file)

with open('resume.json') as resume_file:
    resume = json.load(resume_file)

try:
    validate(instance=resume, schema=schema)
    print("Resume is valid!")
except ValidationError as e:
    print(f"Validation error: {e.message}")

<?php
use JsonSchema\Validator;
use JsonSchema\Constraints\Constraint;

$resume = json_decode(file_get_contents('resume.json'));
$schema = json_decode(file_get_contents('schema.json'));

$validator = new Validator();
$validator->validate($resume, $schema, Constraint::CHECK_MODE_NORMAL);

if ($validator->isValid()) {
    echo "Resume is valid!\n";
} else {
    foreach ($validator->getErrors() as $error) {
        echo sprintf("[%s] %s\n", $error['property'], $error['message']);
    }
}

Contributions are welcome! Please feel free to submit a Pull Request. For major changes:

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

• Follow clean code principles (SRP, DRY, KISS, YAGNI)
• Update CHANGELOG.md for all changes
• Ensure schema remains valid JSON Schema Draft 07
• Add examples for new fields
• Update documentation
• Follow STYLE_GUIDE.md for design and accessibility

See CONTRIBUTING.md for detailed guidelines.

This project is licensed under the MIT License - see the LICENSE file for details.

• JSON Resume - Similar resume schema project
• JSON-LD - JSON for Linking Data
• Schema.org Person - Schema.org vocabulary for people

Schema Resume includes full JSON-LD support for semantic web integration. See JSON-LD.md for:

• Schema.org vocabulary mapping
• RDF conversion examples
• SPARQL query examples
• Integration with knowledge graphs

When validating with validator.schema.org, you need to include @type properties for structured entities. See SCHEMA-ORG-VALIDATION.md for:

• Required @type values for different sections
• Common Schema.org types for projects, work, education
• Troubleshooting validation errors
• Best practices for semantic web integration

This repository includes automated validation tools to ensure schema consistency:

# Lint all schema files
./run-lint.sh

# Compare schemas for consistency
./run-comparison.sh

# Run complete validation suite
./validate-all.sh

• lint-schemas.py - Validates syntax and structure of all 4 schema files:

  • schema.json - Main JSON Schema
  • context.jsonld - JSON-LD context mappings
  • meta-schema.json - Meta-schema definitions
  • schema-resume.xsd - XML Schema

• compare-schemas.py - Compares fields across all schema files to ensure consistency

GitHub Actions automatically validates all schema files on every push and pull request:

• ✅ JSON syntax validation
• ✅ XML schema validation
• ✅ Field consistency checks
• ✅ Structure validation
• ✅ Cross-schema comparison

See .github/workflows/ for workflow details.

Schema Resume is available as official packages for multiple programming languages:

npm install @schema-resume/validator

• Package: @schema-resume/validator
• Documentation: packages/npm/README.md

pip install schema-resume-validator

• Package: schema-resume-validator
• Documentation: packages/python/README.md

go get github.com/tradik/schema-resume/validator

• Package: github.com/tradik/schema-resume/validator
• Documentation: packages/golang/README.md

<dependency>
    <groupId>org.schema-resume</groupId>
    <artifactId>schema-resume-validator</artifactId>
    <version>1.1.0</version>
</dependency>

• Package: Maven Central
• Documentation: packages/java/README.md

gem install schema-resume-validator

• Package: schema-resume-validator
• Documentation: packages/ruby/README.md

composer require schema-resume/validator

• Package: schema-resume/validator
• Documentation: packages/php/README.md

All packages include:

• schema.json - Main JSON Schema for resume validation
• meta-schema.json - Meta-schema for self-validation
• context.jsonld - JSON-LD context for semantic web integration
• schema-resume.xsd - XML Schema Definition (XSD)

For questions, issues, or suggestions:

• Email: info@schema-resume.org or support@tradik.com
• Open an issue
• Submit a pull request

• Add JSON-LD context for semantic web integration
• Create online validator/linter
• Add XML Schema (XSD) support with comprehensive validation
• Create official packages for NPM, Python, Go, Java, Ruby, and PHP
• Add automated release workflow with GitHub Actions
• Create TypeScript type definitions
• Create resume builder web application
• Add support for multiple resume versions
• Implement resume comparison tools
• Add export to PDF functionality
• Create resume templates

See CHANGELOG.md for detailed version history.

This schema is inspired by and compatible with the JSON Resume project, with additional fields and enhanced validation rules for comprehensive CV parsing.

Made with ❤️ for the developer community