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
• Permanently Hosted: Stable, publicly accessible schema URLs 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

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.3.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

Added in v1.2.0. When you have held several roles at the same organization (for example after a promotion), use the positions array to record each role without repeating the organization's details (name, location, url, industry, …). The organization-level fields stay on the work entry, and each role goes into positions. The singular top-level position, startDate, endDate, summary, and highlights fields remain fully valid for single-role entries — this feature is additive and backwards compatible. Prefer either the singular fields or the positions array for the same information, not both.

Each item in positions accepts:

{
  "work": [
    {
      "@type": "schema:Organization",
      "name": "Nexora Digital Ltd",
      "url": "https://nexora-digital.example.com",
      "startDate": "2012-09",
      "endDate": "2016-01",
      "summary": "Progressed from junior engineer to engineering lead across four years",
      "positions": [
        {
          "@type": "schema:EmployeeRole",
          "position": "Junior Software Engineer",
          "startDate": "2012-09",
          "endDate": "2013-12"
        },
        {
          "@type": "schema:EmployeeRole",
          "position": "Senior Software Engineer",
          "startDate": "2015-01",
          "endDate": "2016-01"
        }
      ]
    }
  ]
}

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
• Design tokens and their measured WCAG contrast ratios live in templates/schema-resume/css/tokens.css

See docs/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

schema-resume.org is generated from this repository by spagu/ssg and deployed to Cloudflare Pages. The pages come from content/ and templates/schema-resume/; the documentation pages are built from docs/*.md directly, so a guide has one source, not two.

brew install spagu/tap/ssg   # or see docs/SETUP.md
make install                 # npm ci — build dependencies only
make serve                   # http://127.0.0.1:8888, rebuilds on change
make site                    # build into output/
make site-release            # minified and fingerprinted, as CI builds it

Nothing is loaded from a third-party CDN. Ajv, Chart.js, Mermaid, the XSLT processor and the icon set are pinned in package-lock.json and vendored into the build by tools/build-vendor.mjs and tools/build-icons.mjs. The only outbound requests a page makes are Google Analytics — which does not run until you accept the cookie banner — and the live version badges on the packages page.

The specification is published straight from the repository root through static_sources, so schema.json exists once and is served at its permanent URL. Version-pinned copies come from the frozen snapshots in versions/, never from the live files — that is what makes a pin a pin. See docs/VERSIONING.md.

Every page is published twice: as HTML, and as the Markdown it was authored from at the same URL with a .md extension.

This site documents a machine-readable specification, and a growing share of the people who need it never open the page — they ask an assistant. Serving the authored Markdown means the answer is built from the guide rather than from a guess about which <div> held the content. It costs nothing at runtime: markdown_publish in .ssg.yaml writes static files at build time.

robots.txt names the AI crawlers explicitly, search and training alike, and allows them. The schema is MIT-licensed and every example address in it is fictional; a specification that models have read is a specification developers get right the first time.

Cloudflare settings this repository cannot set. Two dashboard toggles override what is committed here. Email Address Obfuscation must stay off — it rewrites the example addresses inside the JSON samples into [email protected], and the theme's <!--email_off--> guard is a second line of defence, not a substitute. AI Scrapers and Crawlers blocking must also stay off, or it will block at the edge the crawlers robots.txt invites.

Check anything that touches the served HTML with make site-release, not make site. CI builds with --minify-all, and the minifier strips HTML comments — so a host directive such as Cloudflare's <!--email_off--> is present in a make site build and absent from the one that ships. Wrap such a marker in <!--htmlmin:ignore-->…<!--/htmlmin:ignore--> so it survives.

make site fails, rather than warns, on a dead internal link, a missing title or description, an image with no alt text, an orphan page, structured data missing a required property, or a link that only resolves through a redirect. All seven checks were passing in warn mode, so warn was buying nothing but the chance to ship a regression into a log nobody reads.

This repository includes automated validation tools to ensure schema consistency:

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

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

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

• tools/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

• tools/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.3.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