Author Schema: How to Mark Up Authors and Author Pages

Author schema is structured data that tells search engines who wrote a page. You add it as an author property inside your Article or BlogPosting markup, point it at a Person (or Organization) with a name and a URL, and link that URL to an author page that clearly identifies one real person. It will not guarantee a rich result or a ranking lift. It does remove ambiguity about who is speaking, and that matters more every year as search engines and AI answer tools decide whose content to trust.

This guide covers the properties to use, a working example, how to build an author page, how to implement it in WordPress or by hand, and how to test it.

TL;DR

• Author schema is the author property in Article, NewsArticle or BlogPosting markup. Use Person for an individual and Organization for a company.
• Include author.name and, ideally, author.url or sameAs so the author is tied to one unambiguous identity.
• Point the author URL to a dedicated author page and mark that page up with ProfilePage, with the person as its mainEntity.
• Mark up only what visitors can see on the page, then validate with the Rich Results Test and URL Inspection.
• Markup helps Google understand authorship. It does not promise any search feature will appear.

Table of Contents

• What author schema is
• Which properties to include
• A working example
• Building an author page that supports the markup
• How to implement author markup
• Testing and fixing errors
• What author schema can and cannot do
• Our perspective
• Turning author markup into buyer visibility
• A short implementation checklist
• FAQ
• Sources

What author schema is

Schema.org defines author as the author of a piece of content or a rating. It is one property in a shared vocabulary that you can express in JSON-LD, Microdata or RDFa. Schema.org’s own definition also notes that HTML5 has a built-in way to flag authorship with the rel attribute, and that this can be used interchangeably with the property.

In practice, “author schema” and “author markup” mean the same thing: a block of structured data on an article that names the writer in a form machines can read. It usually sits inside Article markup. Google’s Article documentation says you can use Article, NewsArticle or BlogPosting, and that the data helps Google understand the title, images, dates and authors of a piece. It also says Article markup is not required for eligibility in Google News features such as Top stories. So think of it as a clarity tool, not a switch that unlocks a feature.

Which properties to include

Google’s guidance is straightforward. Include author, author.name, and preferably author.url or sameAs. The type matters:

• Use Person for a human author.
• Use Organization when the byline is a company or editorial team.
• Do not use Thing or another wrong type. Google specifically warns against it.

Here is what each property does.

The point of the URL is disambiguation. Two writers can share a name. A link to a page that identifies one specific person lets a search engine tell them apart. Google says the URL should lead to a page that uniquely identifies the author, such as a bio on your site, an about page or a social profile. When the page is an internal author page, Google recommends marking it up with ProfilePage.

One byline, one identity

The most common error is inconsistency. A post says “Jane Smith” in the byline, the schema says “J. Smith,” and the author page says “Jane A. Smith, MBA.” A machine has to guess whether those are one person. Pick one name format and use it in the visible byline, the markup, the author page title and your external profiles.

A working example

This is a minimal BlogPosting with a Person author, in JSON-LD. Replace the placeholder values with your own.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Your article headline",
  "datePublished": "2026-10-15",
  "dateModified": "2026-10-20",
  "author": {
    "@type": "Person",
    "@id": "https://www.example.com/authors/jane-smith#person",
    "name": "Jane Smith",
    "url": "https://www.example.com/authors/jane-smith",
    "jobTitle": "Head of Research",
    "sameAs": [
      "https://www.linkedin.com/in/your-profile"
    ]
  }
}

A few notes on this block:

• The @id gives the person a stable identifier. You can reuse it on the author page and in every article, which ties them together.
• The url matches the live author page, and that page should actually load for everyone, including Googlebot.
• sameAs points to a profile that belongs to this same person. Do not list pages that merely mention them.
• The byline, date and job title in the markup should all appear on the visible page.

If you want to go deeper on the identity side, our guide to knowledge graph SEO explains how these small identifiers add up to an entity that search engines recognize.

Building an author page that supports the markup

The author URL is only as useful as the page behind it. Google’s ProfilePage documentation says a profile page should focus on one person or organization, and that its markup helps Google understand who created or authored content.

What belongs on the page

A good author page is a real page for a real person, not a tag archive with a headshot. Include:

1. Full name, matching the byline exactly.
2. A short bio that states what the person does and why they know the topic. Stick to facts you can support: role, years in the field, education, publications.
3. A photo of the person.
4. Links to external profiles, such as a professional network, a conference page or a publication they write for.
5. A list of recent articles by that person on your site.

ProfilePage markup

The ProfilePage markup identifies the person as the page’s mainEntity. Google’s documentation says it may include a description, an image and external profile links, and can reference recent articles using hasPart along with the author’s entity ID. A simple version looks like this:

{
  "@context": "https://schema.org",
  "@type": "ProfilePage",
  "mainEntity": {
    "@type": "Person",
    "@id": "https://www.example.com/authors/jane-smith#person",
    "name": "Jane Smith",
    "url": "https://www.example.com/authors/jane-smith",
    "description": "Jane leads research at Example Co.",
    "sameAs": [
      "https://www.linkedin.com/in/your-profile"
    ]
  }
}

Because the @id matches the one used inside each article’s author block, the article and the profile describe a single entity. Check Google’s current ProfilePage documentation for the full list of required and recommended properties before you ship.

How to implement author markup

Schema.org vocabulary works in three formats: JSON-LD, Microdata and RDFa. Schema.org’s getting-started guide describes all three and advises marking up content that visitors can see rather than hidden text. JSON-LD is the easiest to maintain because it sits in one block and does not tangle with your page’s HTML.

On WordPress

Google notes that a plugin integrated with your CMS may be easier than hand-coding. The practical path:

1. Use an SEO or schema plugin that outputs Article or BlogPosting markup and lets you set the author object.
2. Fill in each user’s profile fully: display name, bio, website and social links. Most plugins pull from these fields.
3. Make sure the author archive or a custom author page is a true profile, with a bio and a photo, not just a post list.
4. Check the output in the page source. Plugins often default to the author name alone. If you also want url, sameAs or jobTitle, look for a filter, a settings field or a custom field mapping, and confirm it appears in the rendered markup.

If your plugin can’t add a field you need, a small filter in your theme’s code can extend the author object. Keep the added values tied to data stored in the user profile so they never drift from what is on the page.

On a custom or headless site

Generate the JSON-LD from the same data source that renders the byline. When the byline and the markup come from one record, they cannot disagree. Render the author page’s ProfilePage block the same way, and reuse the person’s @id everywhere.

For organizations and multiple authors

If a company byline is genuine, such as “Example Co. Editorial Team,” use an Organization author with a URL to your about page. For multiple writers, list each as its own Person object in an array. Our piece on organization schema markup covers how to describe the company consistently, so the Organization entity and the Person entities support each other.

Testing and fixing errors

Google’s process for ProfilePage is a useful checklist for any author markup. Per its documentation, you add the required properties, follow the guidelines, validate with the Rich Results Test, deploy on accessible pages, check how Google sees the page with URL Inspection, and request recrawling if appropriate.

In practice:

1. Run the Rich Results Test on the live URL and fix every critical error first.
2. Use URL Inspection in Search Console to see the page as Google sees it.
3. Confirm access. The page must not be blocked by robots.txt, set to noindex or placed behind a login.
4. Request a recrawl after significant fixes.

The errors we see most often are mismatches rather than syntax problems:

• A schema author name that differs from the visible byline.
• An author URL that redirects, returns an error or points to a generic team page.
• A sameAs link to a profile that belongs to someone else, or to a dead page.
• Credentials in the markup that appear nowhere on the page.
• Markup on a noindexed or login-gated author page.

What author schema can and cannot do

Be realistic about the payoff. Google says ProfilePage markup can help it understand creators, but that structured data does not guarantee that features using it will appear in search results. Author schema is a clarity signal. It is not a ranking button and it does not replace real expertise, original work or a track record.

Where it earns its place is in the bigger picture of entity recognition. When buyers research a decision in AI-assisted search, the systems answering them pull from sources they can identify and attribute. A named, consistently described author with a verifiable profile is easier to attribute than an anonymous post. That is why author markup fits alongside the rest of your structured data, as covered in our guide to schema types that matter in AI search, and why it supports the entity work described in fixing semantic drift with entity SEO.

Our perspective

Most companies treat author schema as a plugin checkbox. We treat it as one piece of a larger question: when a buyer asks an AI tool to compare providers in your category, does the system know who you are, who speaks for you, and why they are credible?

Schema alone will not answer that. The markup describes an identity, and the identity has to be earned elsewhere: in content that answers real buyer questions, in executive expertise that is visible and consistent, and in external mentions that corroborate what your own site says. When those pieces agree, the markup confirms what the web already shows. When they disagree, markup cannot paper over it.

That is why our managed work connects author and entity clarity to buyer-question research, strategic content, executive LinkedIn content and ongoing visibility monitoring. Fixing the markup is a good first step. Making sure your experts are discovered, understood and considered when buyers evaluate providers is the goal.

Dr. Patrick McAvoy

Turning author markup into buyer visibility

If you have already fixed your schema and still don’t see your company in AI-assisted answers, the gap is usually larger than markup. Authority Engine runs managed AI visibility for established businesses: buyer-question and semantic research, content and publishing, contextual backlinks, community participation, executive LinkedIn content, visibility monitoring and monthly site-health recommendations for your team to implement.

A good place to start is the AI Visibility & Revenue Opportunity Report, which looks at where your company stands today when buyers research and compare. You can also see how this kind of work plays out in our digital marketing agency case study.

A short implementation checklist

Before you close the ticket, run through this list:

• Every article has a visible byline that links to the author page.
• The byline name, the schema name and the author page title match.
• Each author page focuses on one person and carries ProfilePage markup.
• The Person @id is the same in the article and on the profile.
• sameAs lists only profiles that truly belong to that person.
• Company-authored posts use an Organization author with a URL.
• The Rich Results Test shows no critical errors, and URL Inspection shows the page is accessible.
• You review author bios at least once a year so roles and links stay current.

For a wider view of how structured data supports answer engines, our overview of generative engine optimization for marketers shows where schema fits next to content and authority work.

FAQ

Is author schema required for SEO?

No. Google’s documentation says Article structured data is not required for eligibility in features such as Top stories. Author markup is a way to help Google understand who wrote a page. It is worth adding because it is cheap and reduces ambiguity, but it will not rank a thin page.

Should I use Person or Organization as the author?

Use Person when an individual wrote the piece and Organization when the byline is a company or team. Google specifically advises against using Thing or another wrong type. If both apply, name the individual as the author and describe the company through your Organization markup.

What URL should I put in the author property?

Use a page that uniquely identifies that author. Your own author page is the best choice, and Google recommends ProfilePage markup on it. An about page or a social profile can also work, and you can add other profiles under sameAs.

Do I need an author page for every writer?

If you want each writer identified clearly, yes. Give each one a page focused on that person, with a bio, a photo, external profile links and recent articles. Thin pages that only repeat a name add little.

How do I check that my author markup works?

Run the live URL through the Rich Results Test and fix critical errors. Then use URL Inspection in Search Console to see how Google views the page, and confirm it isn’t blocked by robots.txt, noindex or a login.

Sources

• Article structured data, Google Search Central
• Profile page structured data, Google Search Central
• author property, Schema.org
• Getting started with Schema.org

Recommended

• Organization Schema Markup: Reduce AI Brand Confusion for Marketers
• FAQ Schema and SEO in 2026: What Still Works
• Knowledge Graph SEO: How to Get Google to Understand Your Brand
• Fix Semantic Drift Fast: Entity SEO Hub and Spoke for Marketing Teams