How to Use JobPosting Schema to Attract AI-Referred Candidates

Why AI Search Engines Are Becoming a Recruitment Channel

Job seekers are changing their behaviour fast. A growing number of candidates now open ChatGPT or Perplexity before they open Indeed or LinkedIn. They type something like "remote UX designer jobs at SaaS companies paying over £60k" and expect a useful, curated answer. If the AI has no structured data to work from, it cannot surface your listing. It will simply recommend whoever gave it something clear to read.

This is not a future problem. Recruiters and hiring managers who ignore AI-referred traffic right now are already losing candidates to competitors who have taken the time to mark up their job postings properly. The good news is that JobPosting schema is one of the most well-supported schema types in the entire schema.org vocabulary, and implementing it correctly is entirely achievable without a development team.

This guide walks through exactly what JobPosting schema is, which fields actually matter for AI visibility, how to write the JSON-LD, and where to inject it on your site.

What JobPosting Schema Actually Does

JobPosting schema is a structured data format that sits inside your webpage as a block of JSON-LD code. It tells search engines and AI systems the specific details of a job opening in a machine-readable format: the job title, salary, location, employment type, application deadline, and more.

Google has supported JobPosting schema for years and uses it to power the jobs experience in Google Search. But the more interesting development is how large language models (LLMs) like GPT-4o and Gemini use structured data when they crawl or index content. These models are increasingly pulling from pages that give them clear, unambiguous signals. A page that simply says "We're hiring a marketing manager" in flowing prose gives an AI very little to work with. A page with a complete JobPosting schema block tells the AI the job title, salary range, remote/on-site status, contract type, and closing date, all in a format it can immediately parse and relay to a user asking about jobs.

The mechanism matters here. AI systems do not just read your text and summarise it. They favour pages where the data is structured and consistent. JobPosting schema reduces ambiguity. That reduction in ambiguity is what gets you cited.

The Fields That Matter Most for AI Visibility

Google's documentation lists the required and recommended properties for JobPosting schema, but "required for Google" and "useful for AI" are slightly different lists. Here is how to think about it.

Non-negotiable fields

These are the fields you absolutely must include. Miss any of them and you will either fail Google's rich results test or give AI systems so little to work with that they will skip your listing entirely.

• title - The exact job title. Be specific. "Senior Frontend Engineer (React, TypeScript)" beats "Developer".
• description - A full description of the role in plain text. Aim for at least 300 words. AI systems pull from this field directly when generating summaries.
• datePosted - ISO 8601 format: 2025-01-15. Freshness matters to both Google and LLMs.
• hiringOrganization - The name and URL of your company. This is how AI systems attribute the job to your brand.
• jobLocation or jobLocationType - Physical address for on-site roles, or TELECOMMUTE for remote.

High-value recommended fields

These are not strictly required by Google, but they are extremely useful for AI systems generating job recommendations for candidates.

• baseSalary - Salary transparency is a major factor in AI-referred candidates. When a user asks "what does a mid-level data analyst earn at a fintech?", an AI that finds your schema with a clear baseSalary block has something concrete to cite. Include minValue, maxValue, currency, and unitText (YEAR, MONTH, or HOUR).
• employmentType - Use the schema.org values: FULL_TIME, PART_TIME, CONTRACTOR, TEMPORARY, INTERN, VOLUNTEER, PER_DIEM, OTHER.
• validThrough - The application deadline. AI systems treat expired listings as low-quality signals if this date has passed, so keep it accurate.
• experienceRequirements - A plain-text description of the experience level or years required. Useful for AI systems answering "entry-level marketing jobs in Edinburgh".
• skills - List specific skills. This helps AI match your listing to candidate queries that mention specific technologies or competencies.
• identifier - A unique reference number for the posting. Helps AI systems distinguish between multiple similar roles at your company.

A Complete JobPosting JSON-LD Example

Here is a real-world example you can adapt. This covers all the non-negotiable fields and the most impactful recommended ones.

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "JobPosting",
  "title": "Senior Product Designer (B2B SaaS)",
  "description": "We are looking for a Senior Product Designer to join our growing product team in Edinburgh. You will own end-to-end design for our core SaaS platform, working closely with engineering and product management. Responsibilities include user research, wireframing, prototyping in Figma, and shipping polished UI. You should have at least 5 years of experience designing B2B software products, a strong portfolio demonstrating systems thinking, and be comfortable presenting to stakeholders. We use Figma, Notion, and Linear. Benefits include 35 days holiday, remote-first working, private health cover, and a £2,000 annual learning budget.",
  "identifier": {
    "@type": "PropertyValue",
    "name": "AcmeCorp",
    "value": "DESIGN-2025-07"
  },
  "datePosted": "2025-07-01",
  "validThrough": "2025-08-31",
  "employmentType": "FULL_TIME",
  "hiringOrganization": {
    "@type": "Organization",
    "name": "Acme Corp",
    "sameAs": "https://www.acmecorp.com",
    "logo": "https://www.acmecorp.com/logo.png"
  },
  "jobLocation": {
    "@type": "Place",
    "address": {
      "@type": "PostalAddress",
      "streetAddress": "14 Charlotte Square",
      "addressLocality": "Edinburgh",
      "addressRegion": "Scotland",
      "postalCode": "EH2 4DR",
      "addressCountry": "GB"
    }
  },
  "jobLocationType": "TELECOMMUTE",
  "applicantLocationRequirements": {
    "@type": "Country",
    "name": "United Kingdom"
  },
  "baseSalary": {
    "@type": "MonetaryAmount",
    "currency": "GBP",
    "value": {
      "@type": "QuantitativeValue",
      "minValue": 65000,
      "maxValue": 80000,
      "unitText": "YEAR"
    }
  },
  "skills": "Figma, UX Research, Interaction Design, B2B SaaS, Design Systems",
  "experienceRequirements": "Minimum 5 years of product design experience in a B2B software environment.",
  "educationRequirements": "Degree in Design, HCI, or related field preferred but not required."
}
</script>

Notice a few things about this example. The description field is detailed and written in natural language, not just bullet points. It includes real specifics: tools, benefits, number of days holiday, team structure. AI systems use this prose when generating summaries, so thin descriptions produce thin citations. The salary range is explicit. The location includes both a physical address and TELECOMMUTE, which covers hybrid roles accurately.

Where to Inject JobPosting Schema on Your Site

The JSON-LD block should live inside the <head> or <body> of the specific job listing page. It should not sit on your careers homepage unless that page is the canonical URL for the job. Each individual listing should have its own schema block.

WordPress

If you are using WordPress, you can inject the script via your theme's functions.php file using wp_head, or use a plugin that supports custom JSON-LD per post. Some teams use a Custom Fields approach, pulling job data into a template that auto-generates the schema block. For a deeper look at injecting JSON-LD without relying on a plugin, see our guide on how to add JSON-LD to WordPress without a plugin.

Shopify

For businesses running a Shopify site that also has a careers section (less common but it happens), the JSON-LD block can be added directly to the relevant page template in the theme editor. Be careful not to use a jobs-specific app that injects conflicting schema, as duplicate schema blocks can confuse crawlers.

Custom or headless sites

On a custom-built or headless site, the simplest approach is to server-render the JSON-LD block into the page HTML for each job listing. If you are using a JavaScript framework like Next.js, use next/head to inject it into the document head server-side so it is visible to crawlers that do not execute JavaScript.

Keeping Your Schema Fresh and Accurate

One of the fastest ways to hurt your AI visibility is stale job postings. An AI system that cites a job with a validThrough date of three months ago is going to embarrass itself, and it knows that. LLMs trained on freshness signals will deprioritise or ignore expired listings.

Set a process: when a role is filled or closed, either remove the page or update the schema to reflect the closure. If you use an ATS (Applicant Tracking System) that auto-generates job pages, check whether it also outputs schema markup and whether that markup includes validThrough. Most ATS platforms do not do this well by default.

Also update the datePosted field if you significantly refresh a listing. AI systems treat recency as a quality signal, and a posting from six months ago with no updates will lose out to a freshly posted role for the same search query.

Testing Your JobPosting Schema

Once your schema is live, test it in two places. First, use Google's Rich Results Test (search.google.com/test/rich-results) to confirm the markup is valid and eligible for Google's job listings feature. Second, paste your URL into Schema Markup Validator (validator.schema.org) to check for any warnings or errors at the schema.org level.

Pay attention to warnings, not just errors. A warning about a missing recommended field might not break your Google rich result, but it could reduce the quality of information available to AI systems. Fill in as many recommended fields as you reasonably can.

If you want a broader view of how AI-ready your site is across all schema types, not just job postings, FlinnSchema's free AI visibility audit will show you exactly where you stand and what is missing.

Beyond Schema: Supporting Signals for AI-Referred Recruitment

Schema is the foundation, but AI systems also draw on other signals when deciding whether to recommend your job listing to a candidate.

Your company's Organization schema matters. If an AI is asked "is Acme Corp a good company to work for?", it will look for organisation-level signals including your About page, your reviews on third-party platforms, and your schema markup. A well-structured Organization block that includes your company description, founding date, number of employees, and social profiles gives AI systems far more context about who is hiring, which makes the recommendation feel more trustworthy.

Your FAQPage schema on the careers page can also help. Candidates often ask AI systems questions like "does Acme Corp offer remote working?" or "what benefits does Acme Corp offer?". If your careers FAQ is marked up with FAQPage schema, those answers are surfaced directly, without the candidate needing to read through your whole careers page.

At FlinnSchema, we work with e-commerce brands on exactly this kind of multi-layered schema strategy, making sure every type of structured data on a site reinforces the others rather than existing in isolation.

Frequently Asked Questions

Does JobPosting schema work for agency recruiters, or only direct employers?

It works for both, but the hiringOrganization field should reflect the actual employer, not the agency. If you are an agency posting on behalf of a client, include the client's company name and URL in hiringOrganization. You can also add an employmentUnit field or use the description field to clarify that applications are managed through your agency. Transparency here helps AI systems present accurate information to candidates.

Will JobPosting schema help my listings appear in ChatGPT or Perplexity, not just Google?

Yes, though the mechanism is slightly different from Google. ChatGPT and Perplexity do not directly index your schema in real time the way Google does. They rely on crawled content and, in the case of Perplexity, live web retrieval. Structured data helps by making your page content unambiguous and machine-readable. When an AI retrieves your page to answer a job-related query, a complete JobPosting schema block gives it clean, reliable data to pull from. That makes citation far more likely than a page with no structured data at all.

How many job postings can I have on one page?

Each job posting should have its own dedicated page with its own schema block. Do not put multiple JobPosting schema blocks on a single page for different roles. Search engines and AI systems expect a one-to-one relationship between a page and a job listing. A careers listing page that shows 20 jobs should link to 20 individual pages, each with their own schema.

My jobs are pulled from an ATS feed. Can I still add JobPosting schema?

In most cases, yes, though it depends on how your ATS generates pages. Some ATS platforms like Greenhouse, Lever, and Workday allow you to embed your job listings on your own domain using iframes or JavaScript widgets. If the jobs are rendered in an iframe from a third-party domain, your schema has to live on the third-party domain and you have limited control. If they are rendered via JavaScript on your own domain, you can inject schema server-side or use a tag manager approach. The cleanest solution is to have your ATS feed job data into your own page templates so you control the full HTML output, including the schema block.