Show the author's name in a byline, link it to one dedicated author page, and point the article's author at a Person with the same name, the author page URL and a stable @id. Then mark the author page as a ProfilePage whose mainEntity is that same Person. That chain is the whole setup.

The steps are the same on WordPress, Shopify, Wix, Squarespace, Webflow, HubSpot or a hand-built site. The markup identifies the author. It does not create skill, verify credentials, or promise a ranking, a rich result or an AI citation.

The people in the examples are fictional and live on example.com.

Key takeaways

  1. Connect byline and PersonLink the byline to one author page, then point the article's author at a Person with the same name, URL and stable @id.
  2. Set E-E-A-T expectationsGoogle says E-E-A-T is not a specific ranking factor. Markup labels who wrote a page, but it promises no ranking, rich result or citation.
  3. Build one page per authorBuild one public page per author with a stable URL and a short biography. Include only credentials and profile links you can support.
  4. Mark up the profileOn the author page, publish a ProfilePage whose mainEntity is the same Person. Google requires mainEntity and mainEntity.name for its ProfilePage feature.
  5. Skip unsupported propertiesAdd jobTitle, worksFor, alumniOf and knowsAbout only when current and true. Schema.org says knowsAbout does not imply the person is skilled in a topic.
  6. Test and retestUse the Schema Markup Validator, the Rich Results Test, and URL Inspection in Search Console and Bing. Retest after any change to the author or the article.

Terms the setup uses: author, Person, ProfilePage and @id

author is the article property that names who wrote it. Google's Article documentation says to use Person for an individual and Organization for an organization. "Person schema" and "author schema" are one pattern seen from two sides: author is the property on the article, and Person is the type it points to.

Person is the Schema.org type that describes one individual. ProfilePage is the type for a page whose main subject is one person or organization, such as an author page, an "About me" page or an employee page. Google documents a ProfilePage feature for pages like these.

@id is the label that ties the pieces together. When the article, the author page and the Person all use the same absolute URL as an identifier, such as https://example.com/authors/maya-chen#person, a reader of the markup knows they describe one individual. The W3C JSON-LD 1.1 specification defines @id as part of the syntax; it is a naming tool, not a ranking field.

What the markup says about E-E-A-T, and what it cannot do

Google says trust is the most important part of E-E-A-T, and that E-E-A-T is not itself a specific ranking factor. It says quality raters use these ideas to judge whether its systems return useful results, and that rater feedback does not directly rank individual pages (Google Search Central, people-first content guidance).

The same guidance recommends a visible byline and a link to more information about the author. It also warns against invented names, credentials or profile images. So, the useful way to read E-E-A-T is as a transparency checklist for your own pages: who wrote this, what is their background, and where can a reader learn more?

Markup supports that checklist by labelling the answers in a form software can read. It cannot supply the answers. A Person node does not turn a first-time writer into a specialist, and a visible biography only helps when it is true. Bing makes a similar point in its Webmaster Guidelines: structured data should reflect the visible content and does not guarantee visibility or traffic.

Build the author page first

Create one public page per author with one stable URL, for example https://example.com/authors/maya-chen. Everything else in the markup points at this URL, so choose it once and keep it. If the address changes, redirect the old one and update every reference.

The visible page is what readers and systems use to confirm the markup, so write it for readers. Include the facts that apply:

  • The author's name, exactly as it appears in bylines.
  • A short biography.
  • A current role or affiliation, if relevant.
  • Experience, education or credentials you can support.
  • The topics the author covers.
  • Links to articles the author wrote or reviewed.
  • A real portrait, if one is available.
  • Links to authentic external profiles.

Give each person their own page. A company "About" page that covers many unrelated topics is not automatically a personal profile page, and Google's ProfilePage documentation asks for a page that focuses on one person or organization. When an article is bylined to the organization itself, the author is an Organization and no Person is needed.

Add the byline and the article markup

The byline is plain HTML that readers see. It shows the name and links to the author page, and the visible name should match the name value in the markup.

html
<p class="byline">
  By <a href="https://example.com/authors/maya-chen">Maya Chen</a>
</p>

The article markup then names the same person. Google says author, author.name and author.url are recommended properties for its Article feature, alongside headline, image, datePublished and dateModified, and that no Article property is strictly required. Use one author object per author, and never combine several names into one name value. Put a job title in jobTitle, not in name.

In the example below, replace the headline, URLs, dates and names with your own. Keep the author @id and url identical on every article by the same person. The publisher points to an Organization node; the Organization guide covers what that node should hold.

json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "BlogPosting",
      "@id": "https://example.com/blog/structured-data-basics#article",
      "url": "https://example.com/blog/structured-data-basics",
      "headline": "Structured Data Basics for Small Websites",
      "image": [
        "https://example.com/images/structured-data-16x9.jpg",
        "https://example.com/images/structured-data-4x3.jpg",
        "https://example.com/images/structured-data-1x1.jpg"
      ],
      "datePublished": "2026-06-10T09:00:00-05:00",
      "dateModified": "2026-07-02T14:30:00-05:00",
      "author": {
        "@type": "Person",
        "@id": "https://example.com/authors/maya-chen#person",
        "name": "Maya Chen",
        "url": "https://example.com/authors/maya-chen"
      },
      "publisher": { "@id": "https://example.com/#organization" },
      "mainEntityOfPage": { "@id": "https://example.com/blog/structured-data-basics" }
    },
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Example Publishing Group",
      "url": "https://example.com/"
    }
  ]
}

This is demonstration code with fictional facts. Show it to readers as displayed code, and never paste the Maya Chen details into your own page's JSON-LD. The Article schema guide explains the rest of the article properties.

Mark up the author page as a ProfilePage

On the author page, publish a ProfilePage whose mainEntity is the Person. Google's ProfilePage documentation says mainEntity is required, that it must be a Person or an Organization, and that mainEntity.name is required. It lists dateCreated and dateModified as recommended when they apply, and alternateName, description, identifier, image and sameAs as recommended profile details.

The example repeats the same @id that the article used, so the article and the profile describe one individual. The optional hasPart list connects the profile to articles that have their own URLs and markup. Add only the properties you can support on the visible page; delete the rest rather than leaving them blank.

json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "ProfilePage",
      "@id": "https://example.com/authors/maya-chen#profile",
      "url": "https://example.com/authors/maya-chen",
      "name": "Maya Chen, Structured Data Writer",
      "dateCreated": "2026-05-01T10:00:00-05:00",
      "dateModified": "2026-07-01T11:00:00-05:00",
      "mainEntity": {
        "@type": "Person",
        "@id": "https://example.com/authors/maya-chen#person",
        "name": "Maya Chen",
        "url": "https://example.com/authors/maya-chen",
        "image": "https://example.com/images/maya-chen.jpg",
        "description": "Maya Chen writes about website publishing and structured data.",
        "jobTitle": "Structured Data Writer",
        "worksFor": { "@id": "https://example.com/#organization" },
        "alumniOf": {
          "@type": "EducationalOrganization",
          "name": "Example Institute",
          "url": "https://example.com/example-institute"
        },
        "knowsAbout": ["Structured data", "JSON-LD", "Website publishing"],
        "sameAs": ["https://example.com/profiles/maya-chen"]
      },
      "hasPart": [
        { "@id": "https://example.com/blog/structured-data-basics#article" }
      ]
    },
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Example Publishing Group",
      "url": "https://example.com/"
    }
  ]
}

Do not add interaction counts such as follower or comment totals unless the profile page visibly shows those platform-specific numbers. For how nodes in one block refer to each other, the JSON-LD graph guide goes deeper. The Person schema generator builds a Person node from the facts you enter.

Choose Person properties you can support

Add a property only when it is true, current and supportable from the visible page. Omit anything unknown, outdated or private. These are the properties that matter most:

name is the public name, identical to the byline and the profile heading. url is the canonical author page. sameAs is a URL to a reference page that unambiguously identifies the same person, so list only profiles the person controls or that are clearly about them. The entity SEO guide covers sameAs choices in depth.

jobTitle is a current, publicly supportable title. worksFor names a current employer or organization, and it belongs only while the relationship is current. alumniOf is for a school or organization the person actually attended; a course, a conference or a client is not an alumni relationship.

knowsAbout lists topics a person knows about. Schema.org says the property does not imply the person is skilled in a topic and does not distinguish skill levels, so treat it as a topic association and never as proof. description should match the visible biography without unsupported superlatives, and image should be a real portrait, not a generic avatar or a generated headshot.

What Google documents for this markup

Google documents the Article feature and the ProfilePage feature, and it does not document a standalone Person rich result. A Person node therefore earns its place by connecting an author to an article or by serving as the mainEntity of a profile page. Valid Schema.org properties with no documented Google display use are not errors; they simply describe the person for any system that reads them.

Required and recommended labels belong to a specific feature. For Google's ProfilePage feature, mainEntity and its name are required. For Google's Article feature, the author properties are recommended. Correct markup does not guarantee a rich result in either case.

Google changes structured data documentation and supported displays over time, so check its documentation updates page before you rely on a property label.

Author and profile properties and their Google status

Hover over or tap a row to highlight it. On small screens the table scrolls sideways.

PropertyStatus for the Google featureWhat to do
author, author.name, author.urlRecommended for the Article featureMatch the byline and point url at the author page.
mainEntityRequired for the ProfilePage featureMake it the Person or Organization the page is about.
mainEntity.nameRequired for the ProfilePage featureUse the name shown in the byline.
dateCreated, dateModifiedRecommended when applicableAdd real dates for the profile page.
sameAs, image, descriptionRecommended profile details when applicableAdd only profiles, portraits and text that are true.
jobTitle, worksFor, alumniOf, knowsAboutValid Schema.org, not listed for the ProfilePage featureAdd only when current and supportable.

Bing supports Schema.org in JSON-LD, Microdata and RDFa, so the same author markup serves both Google and Bing (Bing structured data help). DuckDuckGo says much of its web-link and image results come from Bing (DuckDuckGo help), so crawlable pages help there too. Apple asks site owners to let Applebot crawl public content (App Search guide), and Yandex offers a structured data validator.

To keep a page eligible for ChatGPT summaries and snippets, avoid blocking OAI-SearchBot (OpenAI publisher FAQ). Microsoft says Copilot web search can use Bing to ground its answers (Microsoft Learn). Keep the author visible in the page text, link to a crawlable author page, and put important claims in ordinary text rather than only in JSON-LD. For more, see whether AI systems use schema markup.

Check what your platform already outputs

Before you add anything, look at what the theme, plugin or app already prints. An existing author value or a BlogPosting block may only need updating, and a second copy describes the same article twice. View the rendered page source of one article and one author page, and search for "author" and "ProfilePage".

A woman with grey hair and a rust cardigan reads a laptop screen beside a printed page at a wooden desk in a small newsroom
Figure 1. Reading the rendered page first shows whether the theme or plugin already prints an author block.

On WordPress, core user profiles hold a public display name, a biography, a website and a profile image (WordPress profile documentation), but themes and plugins decide the markup that comes out. The WordPress schema guide shows how to find and update that output.

Shopify's help center explains how to manage blogs, so inspect the rendered page first and add JSON-LD only where your theme or an app supports it. Wix allows manual JSON-LD through its SEO settings and manages certain preset markups itself, and it says rich results are not guaranteed (Wix structured data help). Squarespace says it generates structured data for blog posts automatically and that the built-in markup cannot be edited or removed (Squarespace help).

For Webflow, use the current Custom Code documentation to find where JSON-LD goes, then inspect the rendered HTML. HubSpot documents a BlogPosting structured data setting and warns against enabling it when custom schema already exists, because duplicate markup can cause problems (HubSpot blog settings). On Next.js, the documentation recommends rendering JSON-LD in a script tag inside a page or layout component (Next.js documentation).

Test the setup on the live page

Run three kinds of test, because each answers a different question. The Schema Markup Validator checks syntax and Schema.org vocabulary. Google's Rich Results Test checks the Google features that apply, here Article and ProfilePage; Google describes both tools on its structured data testing page. Then inspect the live URL in the URL Inspection tool in Search Console and in Bing Webmaster Tools. Bing's URL Inspection has a Markup card for details and errors, and a Live URL test that shows what Bingbot sees.

Three article cards connected by straight lines to one ring node on a central profile card, one line brighter than the others
Figure 2. Every article by one writer points at the same Person node, so a corrected profile reaches them all.

You can also paste the code into the Schema Nova validator for a syntax check, and Yandex users can run the Yandex validator linked above. Testing shows how a tool reads the page. It does not promise a display, a ranking, a citation or traffic.

When something looks wrong, the usual causes are a mismatch between the byline and name, an author url that redirects, two different @id values for one person, and a theme and a plugin both printing an author block. Fix the page, then test again.

Test again after any change to the author, the employer, the URL or the article. The Person schema generator is a quick way to rebuild a corrected Person node.

Connect an author in six steps

Validators show how a tool reads the page. They do not promise a display, ranking, citation or traffic.

  1. Publish the author pageGive one person one page, one stable URL and a visible biography.
  2. Show the bylineDisplay the same name on each article and link it to the author page.
  3. Define the PersonAdd a Person with name, url and a stable @id on the author page.
  4. Mark up the profileAdd ProfilePage with mainEntity pointing at that Person.
  5. Reference it in each articlePoint author at the same @id, with name and url.
  6. Test and maintainTest with the validators and Bing, then retest after any change.

Questions people ask

Does Person schema improve E-E-A-T?

Google says E-E-A-T is not itself a specific ranking factor, so no markup can add it. Person markup labels who wrote a page; the visible biography, accurate byline and real credentials are what readers can judge.

Can an organization be an article author?

Yes. Google says to use Organization as the author type when an organization wrote the article, and Person for an individual. Use one author object per author, and never join several names into a single name value.

Is ProfilePage required for every author page?

No. Google's ProfilePage feature is for pages whose main focus is one person or organization, and it needs mainEntity and mainEntity.name. An author page without ProfilePage can still be linked from the article's author.url.

What is organization schema, and should it be on every page?

Organization schema describes a company, publisher or other organization with its name, URL, logo and profiles. The Organization guide explains what to include, and where Organization schema belongs covers placement across page templates.

Does Person schema make ChatGPT cite my page?

OpenAI says publishers who want ChatGPT summaries and snippets should avoid blocking OAI-SearchBot. Keep the author visible and the page crawlable, and treat any citation as outside your control.

Quick check: identity, not proof

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

Which statement is correct?

Question 2 of 3

What does Schema.org say about knowsAbout?

Question 3 of 3

Which property is required for Google's ProfilePage feature?

Author markup terms

Select a term to see its definition.

Person. A Schema.org type that describes one individual.