Complete Guide to Job Posting Schema for Google Jobs (2026)

Google silently drops job listings that are missing even one required field — no warning, no partial credit. Here’s exactly what to include, what to skip, and how to check your work before you publish.

Most job pages that fail to appear in Google for Jobs aren’t victims of some algorithm mystery — they’re missing a property, or they’ve got a mismatch between what the schema says and what’s visible on the page. Google validates JobPosting markup against a strict checklist, and if something required is absent, malformed, or doesn’t match the page content, the entire listing is quietly excluded. No error message reaches you unless you go looking for it in Search Console.

This guide covers every property Google actually uses — required, recommended, and beta — with working JSON-LD you can copy, a remote-job variant, the salary formatting rules that trip people up most, and the operational habits (expiring listings, canonical URLs) that matter as much as the code itself.

What JobPosting schema is, and why it matters

JobPosting is a schema.org data type, written in JSON-LD, that describes a single job opening in a format machines can parse — title, employer, location, salary, and posting date, laid out in a structured block rather than left for Google to guess at from surrounding text. When it’s implemented correctly, your listing becomes eligible for Google’s dedicated job search experience: the rich result with filters for location, salary, and employment type that dominates the results page for job-related queries.

Without it, your job page can still rank as a normal blue link. With it, you’re competing for a completely different, higher-visibility surface — one where Indeed, LinkedIn, and ZipRecruiter listings currently crowd out sites that skip structured data entirely.

Required properties (non-negotiable)

These five must be present, accurate, and matched to what’s visible on the page. Miss one and the listing isn’t eligible — Google doesn’t partially display a job.

Recommended properties

None of these are required for eligibility, but Google explicitly states that listings with more of these fields are shown preferentially — users consistently prefer postings with a real salary over ones without.

Beta properties

Google introduced a set of beta properties around degree and experience requirements, part of a broader push — followed by employers like Google, Apple, and IBM — to support skills-first hiring. They may not visibly affect search results yet, but implementing them now costs little and positions your listings ahead of the curve if they graduate to fully supported status.

• educationRequirements — accepts plain text or a structured EducationalOccupationalCredential.
• experienceRequirements — years of experience or an OccupationalExperienceRequirements object.
• experienceInPlaceOfEducation — a boolean flagging whether relevant experience can substitute for the formal education requirement.

Full JSON-LD code example

A complete, standards-compliant example combining the required and recommended properties. Replace every value with your actual job data — Google checks that the markup matches the visible page content.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "JobPosting",
  "title": "Senior DevOps Engineer",
  "description": "<p>We're looking for a Senior DevOps Engineer to own our CI/CD pipeline, manage cloud infrastructure, and mentor junior engineers. Requires 5+ years with AWS, Terraform, and Kubernetes.</p>",
  "datePosted": "2026-07-10",
  "validThrough": "2026-09-10",
  "employmentType": "FULL_TIME",
  "hiringOrganization": {
    "@type": "Organization",
    "name": "Acme Technologies",
    "sameAs": "https://acmetech.example.com",
    "logo": "https://acmetech.example.com/logo.png"
  },
  "jobLocation": {
    "@type": "Place",
    "address": {
      "@type": "PostalAddress",
      "streetAddress": "500 Market St",
      "addressLocality": "San Francisco",
      "addressRegion": "CA",
      "postalCode": "94105",
      "addressCountry": "US"
    }
  },
  "baseSalary": {
    "@type": "MonetaryAmount",
    "currency": "USD",
    "value": {
      "@type": "QuantitativeValue",
      "minValue": 130000,
      "maxValue": 165000,
      "unitText": "YEAR"
    }
  },
  "directApply": true
}
</script>

Remote job schema

Fully remote roles use a different location pattern. Drop jobLocation in favor of jobLocationType, and always pair it with applicantLocationRequirements so Google knows which countries or regions are actually eligible to apply — omitting this is one of the most common reasons remote listings underperform in Google Jobs.

{
  "@type": "JobPosting",
  "title": "Remote Customer Success Manager",
  "jobLocationType": "TELECOMMUTE",
  "applicantLocationRequirements": {
    "@type": "Country",
    "name": "USA"
  }
}

Salary markup, done correctly

Salary is the field with the most avoidable mistakes. A few rules that keep it clean:

• Use a real figure the employer actually offers — never estimate or fabricate a number to “fill the field.” Google can flag inflated or invented salary data with a manual action.
• For a range, use minValue and maxValue inside QuantitativeValue rather than a single guessed midpoint.
• Set unitText correctly — YEAR, HOUR, MONTH, or WEEK — since Google normalizes salaries for filtering and comparison across listings.
• If your company doesn’t disclose salary and you’re not legally required to, omit baseSalary entirely rather than guessing. You lose the salary filter’s visibility boost, but that’s a smaller cost than an inaccurate figure.
• Several jurisdictions — including California, Colorado, New York, and Washington — legally require salary disclosure in job postings; check applicable state or regional law before omitting it for roles based there.

How to implement it in WordPress

1. Confirm your theme or plugin generates it automatically

   A job board theme or plugin built with Google Jobs in mind should output a valid JobPosting block for every listing without manual coding. Check a live job page’s source code (or the Rich Results Test) before assuming it’s missing.

2. If it’s missing, add it via your SEO plugin

   Rank Math and Yoast SEO Premium both support custom schema types, including JobPosting, with field mapping to your job listing’s custom fields — no need to hand-write JSON-LD for every post.

3. Map fields to match what’s visible on the page

   Whatever tool you use, the title, description, location, and salary in the schema must exactly mirror the content a visitor sees. Mismatches — even minor ones — are treated as a spam signal.

4. Validate before publishing at scale

   Run a handful of live job URLs through Google’s Rich Results Test. Confirm the JobPosting type is detected with no errors before rolling the same template out across hundreds of listings.

5. Submit a sitemap and connect the Indexing API

   A sitemap gives Google full-site coverage; the Indexing API is what actually gets new and updated job pages crawled within hours instead of days. For a job board with daily postings, skipping the Indexing API means new jobs go stale in search before they’re even indexed.

Common errors and how to fix them

Do’s and don’ts

Frequently asked questions

Resources and validation tools

• Google Search Central: JobPosting structured data
  Google’s canonical documentation for required, recommended, and beta properties.
• Google Rich Results Test
  Validate a live job URL and confirm Google detects the JobPosting type with no errors.
• Schema Markup Validator
  General-purpose schema.org syntax validation, useful alongside Google’s own tool.
• Schema.org: JobPosting reference
  The full property list, including fields Google doesn’t currently process but other search and AI engines may.
• How to Create a Job Board Website Like Indeed Using WordPress
  The full build guide this schema reference supports — theme setup, features, and monetization.
• WPNova Job Board WordPress Theme
  Built-in JobPosting schema generation for every listing, no manual markup required.

Schema requirements reflect Google Search Central’s JobPosting documentation as of July 2026 and are subject to change. Always confirm current required properties against Google’s official documentation before publishing at scale.