There is no "post a job" button on Google. Google for Jobs is not a job board — it is a search feature that reads structured data (JobPosting schema) from pages Google already crawls, plus feeds from partner boards. So "posting a job on Google" really means one of three things: publish on a board that syndicates to Google, add the schema to your own careers page, or use an ATS that emits it for you. This guide covers all three, what Google actually requires, why listings get rejected, and how to check that yours went live — without writing a line of JSON-LD yourself.

What Google for Jobs Actually Is

When someone searches "python developer jobs in Warsaw", Google shows an interactive jobs box above the organic results. Every listing in that box comes from one of two places:

  • Structured data on a web page. Google crawls a job page, finds a JobPosting block in the HTML, validates it, and adds the listing. This is the path for careers sites and ATS-hosted job pages.
  • Partner job boards. Boards that publish schema on their own listing pages, or send feeds directly, get their jobs in the same way. Not every board participates — Indeed, for one, has never syndicated its listings to Google for Jobs.

Two things follow. First, it is free: Google charges nothing to appear in the jobs box, and there is no "sponsored" tier. Second, you cannot submit a job directly — Google has to find it on a page. Everything below is about making that page exist and getting Google to it.

Three Ways to Get a Job on Google

1. Post on a board that syndicates to Google

The zero-effort route. LinkedIn, ZipRecruiter, Glassdoor and many national boards mark up their listing pages with JobPosting schema, so a job posted there shows up in Google's box under the board's name. The trade-offs: your listing carries the board's branding and expiry rules, the apply link goes through the board, and if you post the same role on four boards Google may show four near-identical entries (or pick one). Check each board's help centre for "Google for Jobs" before assuming it participates.

2. Add JobPosting schema to your own careers page

The developer route. Each job page on your site gets a JSON-LD block describing the role. Google's JobPosting structured-data documentation lists the properties:

Property Required? What it must contain
titleRequiredThe job title only — not "Hiring now!!!" or a list of roles
descriptionRequiredThe full job description in HTML (paragraphs, lists), not a teaser
datePostedRequiredISO 8601 date the job was published
hiringOrganizationRequiredThe employer's name (and logo/URL if you have them)
jobLocationRequiredA postal address; for remote roles, jobLocationType: TELECOMMUTE plus the countries applicants may live in
validThroughRecommendedThe date the listing expires — Google uses it to drop stale jobs
employmentTypeRecommendedFULL_TIME, PART_TIME, CONTRACTOR, TEMPORARY, INTERN, VOLUNTEER, PER_DIEM, OTHER
baseSalaryRecommendedCurrency, min/max value and the unit (HOUR, DAY, WEEK, MONTH, YEAR)
identifierRecommendedYour internal job ID, so Google can tell two postings apart
directApplyRecommendedOnly when the applicant can complete the application on that same page

Beyond the block itself you need a crawlable page (no login, no JavaScript-only rendering that hides the schema), a sitemap that lists the job URLs, and — this is the part teams forget — a way to take the job down. Google's guideline is explicit: when a role is filled, either remove the page (return 404 or 410) or make sure validThrough is in the past. Sites that keep expired jobs live get their listings dropped and, repeated often enough, a manual action.

3. Use an ATS that emits the schema for you

The route for teams without a developer on call. A modern applicant tracking system hosts a public page per job, writes the JobPosting block from the fields you already filled in, maintains the sitemap, and handles expiry and removal automatically. You publish; the ATS does the rest.

How MindHunt AI Does It (Field by Field)

This is what happens when you tick "Google for Jobs" on a published position in MindHunt AI — useful both as a checklist for your own implementation and to know exactly what Google sees:

  • A public page on a dedicated host. Every published position gets a server-rendered page at jobs.mindhuntai.com/jobs/<slug>, with a canonical slug minted once on first publish. The same HTML is served to every visitor and every crawler — no cloaking.
  • The schema is generated from your position. title and description come from the job itself (the description is sanitised HTML, so your formatting survives), datePosted from the publish date, hiringOrganization and identifier from your company name and the position ID, jobLocation from the location and country you set, jobLocationType: TELECOMMUTE when the work location is remote, employmentType and baseSalary from the public settings (currency, min, max, per hour/day/week/month/year).
  • validThrough is 30 days from publishing, renewed explicitly. You get a reminder seven days before expiry and a "Renew listing" button; nothing silently auto-renews, so Google never sees a zombie job. A past validThrough keeps the page reachable but marks it noindex and drops it from the sitemap.
  • Unpublish or archive returns HTTP 410. That is the strongest "this job is gone" signal Google accepts, and it is what keeps the account in good standing.
  • Eligibility checks before Google sees it. The Details tab tells you why a listing would not qualify: description under 75 words, no company name on the account, distribution switched off, or expired. A listing that fails any check is published on your board but kept out of Google's index and the sitemap until you fix it.
  • Sitemap and robots on the jobs host. jobs.mindhuntai.com/sitemap.xml lists every eligible job; you do not need your own Search Console property for it.
  • Jooble too. A second toggle publishes the same position into an XML feed for Jooble, the aggregator with job sites in 66 countries — the feed carries title, region, country, salary, description, company, job type, dates and expiry. Both toggles are off by default and independent, so you choose per position.
  • Applying stays in your pipeline. The Apply button sends candidates to your application form, so every applicant lands in the same Kanban pipeline as your sourced candidates and the ones arriving from Djinni or the apply e-mail address. (Because the application completes on another page, the schema deliberately omits directApply — Google reserves that flag for on-page applications.)

The job board, the public page, the Google and Jooble distribution and the apply e-mail intake are included on every plan, including Free.

How to Check That Your Job Is on Google

  1. Validate the page. Paste the public job URL into Google's Rich Results Test. It should detect a JobPosting item with no errors. Warnings on recommended fields (salary, for example) do not block the listing.
  2. Search for it. After Google has crawled the page — typically hours to a few days — search the job title plus the location. Your listing appears in the jobs box with the employer name from hiringOrganization.
  3. Search Console, if you run your own careers site. The "Job postings" enhancement report lists valid, warning and error items per URL. An ATS-hosted page is on the vendor's host, so this step is theirs, not yours.
  4. Re-check after edits. Google re-crawls on its own schedule. If you changed the salary or the location, expect the update to take as long as the initial listing did.

Why a Job Does Not Show Up

  • Thin or teaser description. "Great opportunity, apply now" is not a job description. Write the full role — see the job description writing guide for the structure Google (and candidates) expect.
  • No employer name. hiringOrganization is required; a page that omits it is skipped without an error message you will ever see.
  • Multiple roles in one posting. "Developers, designers and PMs wanted" fails validation — one posting per role.
  • Expired jobs left live. Google discounts a site that keeps filled roles online; take them down or expire them.
  • The page needs a login or renders the schema only with JavaScript. Googlebot must see the JSON-LD in the HTML it fetches.
  • It is simply not crawled yet. A brand-new host can take days. Patience beats resubmitting.

Google for Jobs vs Paying for a Board

Google for Jobs gives you free visibility on the one search engine every candidate uses, but it only shows what people search for. A niche senior role with a good title and a full description will surface; a vague title will not. Paid boards add distribution to people who are browsing rather than searching, plus sponsored placement. Most teams do both: publish once with schema (free, permanent), then sponsor on one board for hard-to-fill roles. The free job posting sites guide covers which boards are free and what each does with feeds.

Conclusion

Getting a job on Google is a publishing problem, not a posting problem: the role needs a public page with complete, valid JobPosting data, a sitemap, and a clean exit when it is filled. You can build that yourself, borrow it from a board, or let an ATS emit it every time you hit Publish. Whichever route you take, write the description properly — it is what Google indexes and what the candidate reads.

Publish Once, Appear on Google

MindHunt AI hosts your job page, writes the JobPosting schema, keeps the sitemap current and takes the listing down when you hire. Included on every plan.

Start Free →