Article Schema for Blog Posts and Guides: Complete Implementation

Why Article Schema Matters for AI SEO

When an AI model like ChatGPT or Gemini evaluates your blog post as a potential source, it needs to answer several questions quickly: What type of content is this? Who wrote it? When was it published? Is it current? Is it freely accessible?

Article schema answers all of these questions in a machine-readable format that requires zero guesswork. Without it, AI models must infer content type from HTML structure, guess at authorship from bylines, and estimate freshness from contextual clues. That inference is unreliable -- and when AI has thousands of candidate sources to evaluate, unreliable sources get skipped.

The data backs this up. Research shows that pages with structured data see AI content interpretation improve from 16% to 54%. That is a 3x improvement in how accurately AI understands what your page is about. If you are investing in content optimized for AI citation, Article schema ensures that investment actually reaches AI models in a format they can process.

Article schema is one of the foundational schema types covered in our JSON-LD basics for AI SEO guide. If you are new to structured data, start there before diving into the implementation details below.

Article vs BlogPosting vs TechArticle: When to Use Each

Schema.org defines Article as the parent type, with BlogPosting and TechArticle as specialized subtypes. Each inherits all Article properties but signals different content intent. Choosing the right one matters because AI models use the @type value to set expectations about what the content delivers.

Article

Use Article for general-purpose written content: news stories, opinion pieces, press releases, and any content that does not fit neatly into the blog or technical categories.

{
  "@type": "Article"
}

Best for: News publications, magazine-style content, general informational pages, corporate announcements.

BlogPosting

Use BlogPosting for blog entries, personal journals, editorial posts, and regularly published commentary. This subtype signals that the content is part of an ongoing publication series and reflects an author's perspective or analysis.

{
  "@type": "BlogPosting"
}

Best for: Company blogs, thought leadership posts, industry commentary, case studies published as blog entries.

TechArticle

Use TechArticle for technical tutorials, how-to guides, documentation, and instructional content. This subtype includes the additional proficiencyLevel property (Beginner, Intermediate, Expert) that helps AI models match content to user expertise levels.

{
  "@type": "TechArticle",
  "proficiencyLevel": "Intermediate"
}

Best for: Implementation guides, code tutorials, technical documentation, step-by-step instructions, developer content.

Quick Decision Matrix

| Content Type | Schema Type | Example | |---|---|---| | Company news, press releases | Article | "Q1 2026 Product Update" | | Industry analysis, opinion | BlogPosting | "Why AI SEO Matters in 2026" | | Tutorial with code samples | TechArticle | "Implementing Schema Markup: A Guide" | | Product documentation | TechArticle | "API Reference: Authentication" | | Case study (narrative) | BlogPosting | "How Brand X Grew AI Visibility 300%" | | Case study (technical) | TechArticle | "Technical Audit: Schema Implementation" |

The key rule: If your content teaches someone how to do something technical, use TechArticle. If it shares opinions, analysis, or narrative updates, use BlogPosting. If it is straightforward informational content, use Article.

Complete JSON-LD: Every Property Explained

Here is a fully annotated Article schema with every property you should include for maximum AI visibility. This example uses BlogPosting, but the same properties apply to Article and TechArticle.

{
  // Required: tells parsers this is schema.org vocabulary
  "@context": "https://schema.org",

  // The article type -- swap to "Article" or "TechArticle" as needed
  "@type": "BlogPosting",

  // Unique identifier for this article entity (enables cross-referencing)
  "@id": "https://example.com/blog/ai-seo-guide/#article",

  // The article title -- must match your visible <h1> tag
  "headline": "The Complete Guide to AI SEO for Small Businesses",

  // Short summary (150-160 characters for optimal display)
  "description": "Learn how to optimize your website for AI search engines like ChatGPT, Gemini, and Perplexity. Practical steps for small business owners.",

  // Primary image -- use 1200x630 for optimal social/rich result display
  "image": {
    "@type": "ImageObject",
    "url": "https://example.com/images/ai-seo-guide-hero.webp",
    "width": 1200,
    "height": 630,
    "caption": "AI SEO optimization guide for small businesses"
  },

  // Author as a Person entity with @id for entity linking
  "author": {
    "@type": "Person",
    "@id": "https://example.com/team/jane-smith/#person",
    "name": "Jane Smith",
    "url": "https://example.com/team/jane-smith",
    "jobTitle": "Head of AI SEO",
    "sameAs": [
      "https://linkedin.com/in/janesmith",
      "https://twitter.com/janesmith"
    ],
    "knowsAbout": ["AI SEO", "Schema Markup", "Technical SEO"]
  },

  // Publisher as an Organization entity
  "publisher": {
    "@type": "Organization",
    "name": "Example Company",
    "url": "https://example.com",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png",
      "width": 600,
      "height": 60
    }
  },

  // Original publication date (ISO 8601 format)
  "datePublished": "2026-03-15",

  // Last meaningful update -- keep this current when you revise content
  "dateModified": "2026-03-22",

  // Canonical URL for this article
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/ai-seo-guide"
  },

  // Total word count of the article body
  "wordCount": 2500,

  // The category or section this article belongs to
  "articleSection": "AI SEO",

  // Relevant keywords (array of strings)
  "keywords": [
    "AI SEO",
    "ChatGPT optimization",
    "AI visibility",
    "small business SEO"
  ],

  // Content language (BCP 47 code)
  "inLanguage": "en",

  // Whether the content is free to read (important for AI access evaluation)
  "isAccessibleForFree": true
}

Property-by-Property Breakdown

headline -- Must exactly match the visible <h1> on the page. Mismatches between schema and visible content are a red flag for both search engines and AI models.

author -- Always use a Person object, never a plain string. Include an @id that matches the author's standalone Person schema (more on this in the next section). AI models use author identity to evaluate expertise, which is a core component of E-E-A-T signals.

datePublished / dateModified -- Use ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ). The dateModified value is particularly important for AI models: it tells them whether your content is current. Update this date every time you make a meaningful content revision.

image -- Google requires at least one image for Article rich results. Use the ImageObject type with explicit width/height for best results. The recommended minimum is 1200 pixels wide.

wordCount -- Helps AI models gauge content depth. A 500-word article and a 5,000-word guide serve different purposes, and AI needs to know which it is dealing with.

articleSection -- Maps your article to a topic category. AI models use this to understand your site's topical authority structure.

keywords -- An array of topic terms. Keep it to 5-10 relevant keywords. These supplement AI's own keyword extraction and help with topic matching.

inLanguage -- Critical for multilingual sites. Without this, AI models must detect language from content, which can fail on short or mixed-language pages.

isAccessibleForFree -- Set to true for free content, false for paywalled content. AI models factor this into source selection -- free content is preferred for citations because the AI can link users to it without access barriers.

Connecting Article to Author Person Schema

One of the most impactful things you can do for AI visibility is connect your Article schema to a full Person schema for the author. This creates a linked entity graph -- a network of structured data that AI models traverse to evaluate expertise and authority.

Here is how it works. On the author's profile page (e.g., /team/jane-smith), you define a standalone Person schema:

{
  "@context": "https://schema.org",
  "@type": "Person",

  // This @id is the critical linking element
  "@id": "https://example.com/team/jane-smith/#person",

  "name": "Jane Smith",
  "url": "https://example.com/team/jane-smith",
  "jobTitle": "Head of AI SEO",
  "worksFor": {
    "@type": "Organization",
    "@id": "https://example.com/#organization",
    "name": "Example Company"
  },
  "sameAs": [
    "https://linkedin.com/in/janesmith",
    "https://twitter.com/janesmith",
    "https://github.com/janesmith"
  ],
  "knowsAbout": ["AI SEO", "Schema Markup", "Technical SEO", "Content Strategy"],
  "alumniOf": {
    "@type": "CollegeOrUniversity",
    "name": "MIT"
  }
}

Then in every article Jane writes, the author field references the same @id:

{
  "@type": "BlogPosting",
  "headline": "The Complete Guide to AI SEO",
  "author": {
    "@type": "Person",
    "@id": "https://example.com/team/jane-smith/#person",
    "name": "Jane Smith",
    "url": "https://example.com/team/jane-smith"
  }
}

The matching @id values tell AI models: "This is the same person described in detail on the profile page." The AI can then traverse to the full Person entity to evaluate Jane's credentials, work history, and topical expertise -- all of which feed into E-E-A-T assessment.

Similarly, your publisher should reference your Organization schema using a shared @id:

"publisher": {
  "@type": "Organization",
  "@id": "https://example.com/#organization",
  "name": "Example Company",
  "url": "https://example.com",
  "logo": {
    "@type": "ImageObject",
    "url": "https://example.com/logo.png"
  }
}

This three-way link -- Article to Person to Organization -- is the entity graph that positions your content as authoritative, well-sourced, and trustworthy. AI models that evaluate AI SEO signals weight this kind of structured identity data heavily.

HowTo Schema for Step-by-Step Guides

When your article is a tutorial or step-by-step guide, supplement the Article/TechArticle schema with a separate HowTo schema. This gives AI models a structured representation of the process you are teaching, independent of the article wrapper.

{
  "@context": "https://schema.org",
  "@type": "HowTo",

  // Clear, descriptive name of the process
  "name": "How to Add Article Schema to a Blog Post",

  // Brief summary of what the reader will accomplish
  "description": "Add complete Article JSON-LD schema markup to a blog post for improved AI visibility and Google rich results.",

  // Estimated time to complete all steps
  "totalTime": "PT20M",

  // Tools or software needed
  "tool": [
    { "@type": "HowToTool", "name": "Text editor or CMS" },
    { "@type": "HowToTool", "name": "Google Rich Results Test" }
  ],

  // Each step as a HowToStep with position, name, and detailed text
  "step": [
    {
      "@type": "HowToStep",
      "position": 1,
      "name": "Create the JSON-LD script block",
      "text": "Add a <script type='application/ld+json'> tag in your page's <head> section. Set @context to https://schema.org and @type to BlogPosting, Article, or TechArticle.",
      // Optional: image showing this step
      "image": "https://example.com/images/howto-step1.webp"
    },
    {
      "@type": "HowToStep",
      "position": 2,
      "name": "Add the headline and description",
      "text": "Set the headline property to match your page's H1 tag exactly. Add a description of 150-160 characters summarizing the article content."
    },
    {
      "@type": "HowToStep",
      "position": 3,
      "name": "Define the author Person entity",
      "text": "Add an author property with @type Person. Include @id (matching the author profile page schema), name, url, jobTitle, and sameAs social profile links."
    },
    {
      "@type": "HowToStep",
      "position": 4,
      "name": "Add publisher, dates, and metadata",
      "text": "Set publisher to your Organization entity with logo. Add datePublished and dateModified in ISO 8601 format. Include wordCount, articleSection, keywords array, inLanguage, and isAccessibleForFree."
    },
    {
      "@type": "HowToStep",
      "position": 5,
      "name": "Validate with testing tools",
      "text": "Paste your page URL into Google Rich Results Test to check for errors. Then use Schema.org Validator for full spec compliance. Fix any warnings before deploying to production."
    }
  ]
}

When to Use HowTo vs TechArticle Alone

Use both when your content walks the reader through a sequential process with discrete steps. The TechArticle describes the article as a whole; the HowTo describes the process it teaches. Together, they give AI models two complementary views of the same content.

Use TechArticle alone (without HowTo) when your content is technical but not step-by-step -- for example, a technical comparison, reference documentation, or architecture overview.

For content that includes FAQ sections alongside the how-to process, you can also add FAQ schema as a third JSON-LD block on the same page.

WordPress Implementation

WordPress sites have several options for adding Article schema, depending on your technical comfort level.

Option 1: Plugin-based (Recommended for Non-developers)

Yoast SEO and Rank Math both generate Article schema automatically. However, their default output often omits AI-relevant properties like wordCount, articleSection, keywords, and isAccessibleForFree.

To supplement the plugin output, use the Schema Pro or WP Schema plugin to add missing properties, or add a custom JSON-LD block via a child theme's functions.php:

// Add to your child theme's functions.php
function custom_article_schema() {
    if ( is_single() ) {
        global $post;
        $schema = array(
            '@context'           => 'https://schema.org',
            '@type'              => 'BlogPosting',
            'headline'           => get_the_title(),
            'description'        => get_the_excerpt(),
            'datePublished'      => get_the_date('c'),
            'dateModified'       => get_the_modified_date('c'),
            'wordCount'          => str_word_count( strip_tags( $post->post_content ) ),
            'articleSection'     => get_the_category()[0]->name ?? 'Blog',
            'inLanguage'         => get_locale(),
            'isAccessibleForFree'=> true,
            'author'             => array(
                '@type'    => 'Person',
                '@id'      => get_author_posts_url( $post->post_author ) . '#person',
                'name'     => get_the_author(),
                'url'      => get_author_posts_url( $post->post_author ),
            ),
            'publisher'          => array(
                '@type' => 'Organization',
                'name'  => get_bloginfo('name'),
                'url'   => home_url(),
                'logo'  => array(
                    '@type' => 'ImageObject',
                    'url'   => get_site_icon_url(),
                ),
            ),
            'image'              => get_the_post_thumbnail_url( $post, 'full' ),
            'mainEntityOfPage'   => get_permalink(),
        );

        // Add keywords from tags
        $tags = get_the_tags();
        if ( $tags ) {
            $schema['keywords'] = array_map(
                function($tag) { return $tag->name; },
                $tags
            );
        }

        echo '';
    }
}
add_action( 'wp_head', 'custom_article_schema' );

Important: If you use Yoast or Rank Math, disable their Article schema output first to avoid duplicate schemas. In Yoast, go to SEO > Search Appearance > Content Types and disable schema for Posts. In Rank Math, use the rank_math/json_ld filter.

Option 2: Manual JSON-LD in Post Editor

For individual posts, paste the JSON-LD <script> block directly into the Custom HTML block in the WordPress block editor, or use a plugin like Insert Headers and Footers to add it per-page.

Next.js Implementation

For Next.js applications, generate the JSON-LD dynamically from your content data. Here is a reusable component:

// components/ArticleSchema.tsx
interface ArticleSchemaProps {
  title: string;
  description: string;
  slug: string;
  datePublished: string;
  dateModified: string;
  authorName: string;
  authorUrl: string;
  authorJobTitle: string;
  imageUrl: string;
  wordCount: number;
  section: string;
  keywords: string[];
  type?: 'Article' | 'BlogPosting' | 'TechArticle';
  proficiencyLevel?: 'Beginner' | 'Intermediate' | 'Expert';
}

export function ArticleSchema({
  title,
  description,
  slug,
  datePublished,
  dateModified,
  authorName,
  authorUrl,
  authorJobTitle,
  imageUrl,
  wordCount,
  section,
  keywords,
  type = 'BlogPosting',
  proficiencyLevel,
}: ArticleSchemaProps) {
  const schema: Record<string, unknown> = {
    '@context': 'https://schema.org',
    '@type': type,
    headline: title,
    description,
    image: imageUrl,
    datePublished,
    dateModified,
    wordCount,
    articleSection: section,
    keywords,
    inLanguage: 'en',
    isAccessibleForFree: true,
    mainEntityOfPage: `https://example.com/blog/${slug}`,
    author: {
      '@type': 'Person',
      '@id': `${authorUrl}#person`,
      name: authorName,
      url: authorUrl,
      jobTitle: authorJobTitle,
    },
    publisher: {
      '@type': 'Organization',
      name: 'Example Company',
      url: 'https://example.com',
      logo: {
        '@type': 'ImageObject',
        url: 'https://example.com/logo.png',
      },
    },
  };

  // Add proficiencyLevel only for TechArticle
  if (type === 'TechArticle' && proficiencyLevel) {
    schema.proficiencyLevel = proficiencyLevel;
  }

  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
    />
  );
}

Usage in a page component:

// app/blog/[slug]/page.tsx
import { ArticleSchema } from '@/components/ArticleSchema';

export default function BlogPost({ post }) {
  return (
    <>
      <ArticleSchema
        title={post.title}
        description={post.excerpt}
        slug={post.slug}
        datePublished={post.publishedAt}
        dateModified={post.updatedAt}
        authorName={post.author.name}
        authorUrl={`https://example.com/team/${post.author.slug}`}
        authorJobTitle={post.author.role}
        imageUrl={post.coverImage}
        wordCount={post.wordCount}
        section={post.category}
        keywords={post.tags}
        type="BlogPosting"
      />
      {/* Article content */}
    </>
  );
}

This approach ensures every blog post automatically gets complete Article schema without manual JSON-LD editing.

Testing and Validation

Deploying schema without testing is like shipping code without running tests. Use this three-step validation workflow.

Step 1: Google Rich Results Test

URL: search.google.com/test/rich-results

This tool checks whether your schema qualifies for Google rich results (enhanced search listings). It validates required properties and flags errors that would prevent rich result display.

What to check: Zero errors. Warnings are acceptable but should be addressed when possible.

Step 2: Schema.org Validator

URL: validator.schema.org

This validates your JSON-LD against the full schema.org specification. It catches structural issues that Google's tool misses -- for example, using deprecated properties, wrong data types, or mismatched @id references.

What to check: No structural errors. Pay attention to type mismatches (e.g., using a string where an object is expected for author).

Step 3: Google Search Console Enhancements

After deployment, monitor the Enhancements section in Google Search Console. It shows real-world indexing issues for Article structured data across your entire site. This is where you catch problems that only appear at scale -- like inconsistent author names or missing images on specific pages.

For a detailed walkthrough of all three tools plus AI-specific validation techniques, see our testing structured data guide.

Quick Validation Checklist

• [ ] headline matches the visible <h1> on the page
• [ ] dateModified is actually updated when content changes
• [ ] author.@id matches the Person schema on the author profile page
• [ ] image URL returns a 200 status (not 404)
• [ ] publisher.logo meets Google's size requirements (width 600px max)
• [ ] isAccessibleForFree matches actual page access (no paywall mismatch)
• [ ] No duplicate Article schemas on the same page (check plugin conflicts)
• [ ] JSON-LD is in <head> or <body> (not inside <template> or dynamically loaded)

Common Mistakes

These are the Article schema errors we see most often when auditing websites for AI visibility:

1. Using a string instead of a Person object for author

// WRONG -- AI models cannot extract author entity data from a string
"author": "Jane Smith"

// CORRECT -- Full Person object with linkable @id
"author": {
  "@type": "Person",
  "@id": "https://example.com/team/jane-smith/#person",
  "name": "Jane Smith",
  "url": "https://example.com/team/jane-smith"
}

2. Never updating dateModified

If dateModified equals datePublished on a two-year-old article, AI models treat it as stale content. Update dateModified every time you make a meaningful revision -- not just cosmetic changes, but substantive content updates.

3. Headline mismatch between schema and page

Your headline in JSON-LD must match the visible <h1> tag. If your H1 says "AI SEO Guide 2026" but your schema says "The Complete Guide to Artificial Intelligence Search Engine Optimization", search engines flag the inconsistency and AI models lose trust in the structured data.

4. Missing image property

Google requires image for Article rich results. Many implementations omit it or point to a broken URL. Always verify the image URL returns a 200 status code and the image is at least 1200px wide.

5. Duplicate schemas from plugin conflicts

Running Yoast SEO + a custom JSON-LD block = two Article schemas on the same page. Search engines handle this poorly. Check your page source for duplicate BlogPosting or Article blocks before deploying.

6. Putting JSON-LD in dynamically loaded content

If your JSON-LD is inside a React component that only renders client-side, AI crawlers (which typically do not execute JavaScript) will never see it. Always render structured data server-side or in static HTML.

7. Omitting isAccessibleForFree

If your content is free but you do not declare "isAccessibleForFree": true, AI models cannot be certain the linked source will be accessible to end users. This reduces citation likelihood because AI avoids recommending potentially paywalled content.