EA Digital Solutions
Schema.org für Google Jobs: Strukturierte Daten in Stellenanzeigen richtig implementieren — Hero-Illustration

JobPosting Schema.org Implementation Guide: Get Your Vacancies Listed in Google Jobs 2025

Admin
JobPosting schema.org markup tells Google's job crawlers about your openings—salary, location, job type, and application method. Add it to your HTML, validate with Google's tool, and watch your listings appear in Google Jobs within 24–48 hours.

How to Implement JobPosting Schema Correctly: The 2025 Guide for SMBs and Developers

Last updated: 31 July 2026

Last month, I was reviewing a client's job board for E-TEC GmbH—a mid-sized consulting firm in Vienna. They were posting positions to their careers page, but nothing appeared in Google Jobs. After an audit, I found the problem: their schema markup was incomplete. Missing salary ranges, no hiringOrganization details, malformed location data. Google couldn't understand what they were advertising. Within two weeks of fixing the JobPosting schema, their first qualified candidate came through Google Jobs. That's the difference proper structured data makes.

Why Google Jobs Requires JobPosting Schema

Google Jobs doesn't crawl job listings the way it indexes regular web pages. It relies on structured data—specifically the JobPosting type from Schema.org—to extract critical information. Without it, your job posts remain invisible to the service, no matter how well-written your HTML is.

This isn't optional for visibility. Google explicitly states that JobPosting schema is the primary way to appear in Google Jobs. Your competitors who implement it correctly will capture the attention of job seekers before yours ever appears in search results. For SMBs competing for talent, this gap translates directly into unfilled positions and slower hiring cycles.

The schema also powers other features: job listings in Google Search itself (the rich snippets with salary and company logo), voice search results, and mobile job alerts. Getting it right compounds your reach across multiple platforms.

Core Requirements: What JobPosting Must Include

Google has both required and recommended fields for JobPosting schema. Required fields are non-negotiable—omit them and your listing will be rejected or won't render properly:

  • title: The exact job title
  • description: Full job description (HTML allowed)
  • hiringOrganization: Your company name and logo
  • jobLocation: Where the job is based (even if remote)
  • employmentType: Full-time, Part-time, Contract, Temporary, Intern, Commission, or Other
  • baseSalary: Salary information (currency, value, and unit)
  • validThrough: The date the listing expires

Beyond these, Google strongly recommends:

  • datePosted: When you published the listing
  • applicantLocationRequirements: Where candidates can work from
  • jobLocationType: Telecommute, On-Site, or Hybrid
  • experienceRequirements: Entry level, Mid level, Director level, or Executive level

The difference between a "good enough" implementation and one that actually performs is often in these recommended fields. They help Google rank your listing higher and let candidates filter more precisely.

Practical Implementation: JSON-LD vs. Microdata

I recommend JSON-LD for JobPosting schema, and I'll explain why using a real example from E-TEC GmbH's setup.

JSON-LD is cleaner, easier to maintain, and less error-prone than embedding microdata attributes throughout your HTML. Here's a minimal working example:

unknown node

Place this script tag in your page's <head> section, wrapped in <script type="application/ld+json">...</script>. Google's crawler will parse it separately from your visible HTML, so formatting or typos in the page markup won't break the schema.

Why not microdata? Microdata requires sprinkling Schema.org attributes (itemscope, itemtype, itemprop) throughout your HTML. It's harder to validate, easier to accidentally break when editing content, and makes your markup verbose. JSON-LD keeps the data layer separate and maintainable.

Salary Data: Getting the Range Right

One of the most common mistakes I see is incomplete salary data. Job seekers search by salary range first, and if your schema doesn't include it—or includes only a single figure—you'll lose visibility.

Google expects salary as a range when possible. Here's the pattern:

unknown node

This tells Google: "We're offering between €55,000 and €75,000 annually." Alternatively, you can use minPrice and maxPrice if your CMS or job board system supports it. The unit matters too—specify "YEAR" for annual, "MONTH" for monthly, or "WEEK" for hourly contracts.

For hourly positions (consultants, freelancers), use the same structure but set the unit to "HOUR". Never skip this—it's one of the top ranking factors for Google Jobs visibility in my experience.

Location Data: Local vs. Remote

Location is more complex than it appears. You must specify:

  1. jobLocation (required): The physical or primary office location
  2. jobLocationType (recommended): TELECOMMUTE, ON_SITE, or HYBRID
  3. applicantLocationRequirements (recommended): Countries or regions where candidates can work from

This distinction matters. A HYBRID role based in Vienna might accept applicants from anywhere in Austria. A TELECOMMUTE role might accept EU applicants only. Your schema should reflect these nuances, or you'll either attract unqualified candidates or miss suitable ones.

For multiple locations, repeat the jobLocation object as an array:

unknown node

Validation and Testing

After implementing your schema, validate it before publishing. Google's Rich Results Test (https://search.google.com/test/rich-results) will parse your page and flag errors in real-time. Schema.org's own validator (https://validator.schema.org/) offers another perspective, though it's less strict about Google-specific requirements.

Common validation failures I encounter:

  • Missing or malformed dates: validThrough must be ISO 8601 format (YYYY-MM-DDTHH:MM:SSZ)
  • Incorrect enum values: employmentType must be one of the predefined values, not custom text
  • Broken URLs: logo and sameAs URLs must be absolute and accessible
  • Incomplete address: missing addressCountry or addressLocality prevents proper parsing

Run validation on at least three sample job posts before going live. If you're using a job board platform (like Workable, SmartRecruiters, or custom solutions), check whether they generate valid schema by default. Many don't, and you'll need custom configuration.

Integration with Your Job Board Platform

If you manage jobs through a custom system (as E-TEC GmbH did with a bespoke internal platform), ensure your backend generates correct schema on each job page. This is where developers come in: the schema generation should be templated and automated, not hand-coded for every post.

For platforms like Wix, Shopify, or WordPress with plugins, verify that the plugin outputs valid schema. Many free job board plugins produce incomplete or outdated markup. Paid solutions like Indeed's job posting or LinkedIn's job distribution often include proper schema out of the box—but you should still validate.

If you use a headless or custom frontend (Next.js, Vue, React), generate schema server-side during build time or request time, depending on whether jobs are static or dynamic. Dynamic generation is safer: it ensures every new job automatically gets correct schema without developer intervention.

Monitoring and Updates

Once live, monitor Google Search Console for job-related data. The "Enhancements" section will show whether Google is successfully parsing your JobPosting schema. If errors appear weeks after launch, investigate immediately—schema bugs compound over time as you publish more listings.

Update schema when you edit job details. If you change the salary or extend validThrough, update the schema too. Some systems do this automatically; others require manual updates. Stale schema (e.g., a validThrough date in the past) can cause Google to remove listings from Jobs.

Review your schema implementation annually. Google occasionally updates JobPosting requirements, and the industry evolves. What worked in 2023 might be suboptimal in 2025.

Frequently Asked Questions

What is JobPosting structured data and why does it matter?▾

JobPosting is a schema.org vocabulary that tags job vacancy details—helping Google's indexing engine understand and surface your listings in Google Jobs, LinkedIn, and other aggregators.

Which fields are mandatory for Google Jobs visibility?▾

Title, description, location, employment type, and hiringOrganization are required; salary and datePosted are strongly recommended to rank competitively.

How do I validate my JobPosting markup?▾

Use Google's Rich Results Test or Schema.org validator, paste your page URL or code, and check for errors—green marks mean your markup is ready.

What's the difference between JSON-LD, Microdata, and RDFa?▾

JSON-LD (easiest for SMBs) embeds data in a script tag; Microdata and RDFa distribute tags throughout HTML—JSON-LD is Google's preferred format.

How long until my jobs appear in Google Jobs after adding schema?▾

Google's crawler typically picks up valid JobPosting markup within 24–48 hours; resubmit your sitemap in Search Console to accelerate indexing.

New articles delivered straight to your inbox

  • ✓New articles delivered to your inbox
  • ✓Digital marketing tips for SMEs
  • ✓No spam, unsubscribe anytime

No spam. Unsubscribe anytime.

More articles