Person Schema Markup: Tell Google Who Wrote Your Content (E-E-A-T)

Person schema is the structured data that tells Google a real, identifiable human is behind a page — who they are, what they do, and where else they exist online. It's the machine-readable half of E-E-A-T (Experience, Expertise, Authoritativeness, Trust). You can write the most authoritative article on the internet, but if Google can't tie it to a credible author entity, you're leaving that trust signal on the table.

Here's what Person schema actually does, the JSON-LD that works, and the mistakes that make it useless.

What Person Schema Is (and Isn't)

Person schema uses the schema.org Person type to describe an individual. At minimum it carries a name. Done well, it links a name to a job title, an employer, a photo, and — most importantly — the person's other profiles around the web via sameAs.

What it is not: a ranking button. Adding Person markup doesn't directly boost a page. There's no "author rich result" the way FAQ or Product schema can trigger snippets. So why bother?

Because Google builds an understanding of entities — people, companies, places — and connects them across the web. When your author's name, photo, and LinkedIn all line up in structured data, you're helping Google confirm that the person exists, has relevant expertise, and is the same entity referenced elsewhere. For Your Money or Your Life topics — health, finance, legal — that author trust is a documented part of how Google assesses quality. Person schema is how you feed it cleanly instead of hoping the crawler infers it from a byline.

The Minimum Viable Person Schema

The only required property is name. This is valid:

{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Jane Rivera"
}

Valid, but nearly worthless. A name with no other properties tells Google almost nothing it didn't already get from your byline. The value lives in the connecting properties.

The Version That Actually Helps

Here's a complete, useful Person object:

{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Jane Rivera",
  "url": "https://example.com/about/jane-rivera",
  "image": "https://example.com/team/jane-rivera.jpg",
  "jobTitle": "Senior Tax Analyst",
  "worksFor": {
    "@type": "Organization",
    "name": "Rivera Financial"
  },
  "sameAs": [
    "https://www.linkedin.com/in/janerivera",
    "https://twitter.com/janerivera",
    "https://scholar.google.com/citations?user=xxxx"
  ]
}

Each property pulls weight:

• url points to the author's bio or profile page on your own site. This becomes the canonical "home" for the entity.
• image is the author photo. Use a real headshot at a stable URL, not a rotating avatar.
• jobTitle and worksFor establish relevant expertise. "Senior Tax Analyst" writing about tax deductions is exactly the expertise signal E-E-A-T rewards.
• sameAs is the heavyweight. It's a list of authoritative profiles that confirm this is a real, verifiable person — LinkedIn, X, Google Scholar, a personal site, a Wikipedia page if they have one. This is the strongest entity-disambiguation signal you can send.

You can build this in under a minute with the Schema Markup Generator — pick the Person type, fill in the name, URL, photo, job title, employer, and comma-separated social URLs, and it outputs valid JSON-LD ready to paste.

Where to Put It

Two patterns, depending on the page.

On an author bio page (/about/jane-rivera), drop a standalone Person object describing only that person. This page becomes the entity's anchor on your site.

On an article, don't bolt a loose Person block onto the page. Nest it inside your Article schema as the author value:

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "2026 Tax Deduction Changes Explained",
  "author": {
    "@type": "Person",
    "name": "Jane Rivera",
    "url": "https://example.com/about/jane-rivera"
  }
}

The author.url here should point at the same bio page that hosts the full Person object. That's how you link the two: Google follows the URL, finds the rich Person entity, and connects the article to the credentialed author. A bare "author": "Jane Rivera" string works but throws away that connection.

Either way, place the JSON-LD in a <script type="application/ld+json"> tag in the page's <head> or <body>. JSON-LD is Google's recommended format — you don't need to touch your visible HTML.

sameAs Is Where Most People Get It Wrong

sameAs only helps if the links are real and consistent. Common failures:

• Linking profiles that don't mention the person. If you list a LinkedIn URL, that LinkedIn profile should plausibly be the same human. Google cross-checks. A mismatched profile dilutes the signal instead of strengthening it.
• Pointing to a company page instead of a personal one. linkedin.com/company/... is the Organization. The person needs linkedin.com/in/....
• Inconsistent names across profiles. "Jane Rivera" in schema, "Jane M. Rivera" on LinkedIn, "J. Rivera" on Twitter makes entity resolution harder. Pick one canonical name and use it everywhere.
• Listing weak profiles to pad the array. Three authoritative links (LinkedIn, a personal site, Google Scholar) beat eight throwaway social accounts. Quality of corroboration matters more than count.

Person vs Organization Schema

These get confused constantly. A few quick rules:

• An individual author or expert → Person.
• A company, publisher, or brand → Organization (see the Organization schema guide for the knowledge-panel angle).
• An article's author is usually a Person; its publisher is usually an Organization.

Sole proprietors and personal brands sometimes warrant both — a Person entity for the human and an Organization entity for the business — linked via worksFor and founder. Don't collapse them into one. Google treats people and companies as different entity types, and merging them muddies both.

Validate Before You Ship

Person markup fails silently. A trailing comma or a malformed URL and the whole block gets ignored — no error, no warning, just a wasted signal. Two checks before you publish:

1. Run the JSON-LD through the Structured Data Validator to catch syntax errors and missing recommended fields.
2. Confirm with Google's Rich Results Test that the markup parses, then watch the Enhancements and Crawled reports in Search Console over the following weeks.

Because Person schema doesn't trigger a visible rich result, you won't see an instant SERP change. Its job is slower and structural: feeding Google a clean, corroborated picture of who's behind your content so author authority compounds over time.

The Bottom Line

Person schema won't move a ranking by Friday. What it does is make your authors legible to Google as real, credentialed entities — the foundation E-E-A-T is built on, especially for finance, health, and legal content where trust is the whole game.

Get the connecting properties right (jobTitle, worksFor, and consistent sameAs links), nest it as the author on your articles, host the full entity on a bio page, and validate before you ship. Generate the JSON-LD with the Schema Markup Generator, confirm it with the Structured Data Validator, and let the trust signal build.