opdeck / blog / generate-schema-org-json-ld-blog-post

How to Generate schema.org JSON-LD for Blog Post Using OpDeck Tool

June 5, 2026 / OpDeck Team
JSON-LDSEOStructured DataBloggingOpDeck

If you need to generate schema.org JSON-LD for a blog post, you're in the right place. Structured data is one of those technical SEO tasks that sounds intimidating but pays off significantly — it helps search engines understand your content, can earn you rich results in Google Search, and ultimately drives more qualified traffic to your site. This guide walks you through exactly what JSON-LD structured data is, why your blog posts need it, and how to generate it quickly using OpDeck's JSON-LD Structured Data Generator.

What Is Schema.org JSON-LD and Why Does Your Blog Post Need It?

Schema.org is a collaborative vocabulary maintained by Google, Microsoft, Yahoo, and Yandex. It provides a standardized set of tags that describe the meaning of your web content — not just what it says, but what it is. JSON-LD (JavaScript Object Notation for Linked Data) is the format Google recommends for implementing this structured data because it lives in a clean <script> tag and doesn't require you to touch your HTML content at all.

For a blog post specifically, the relevant schema type is BlogPosting (a subtype of Article). When you add this markup to your post, you're telling search engines:

  • Who wrote the article
  • When it was published and last modified
  • What the article is about
  • Which website it belongs to
  • What the featured image is

This matters because Google uses this information to generate rich results — enhanced search listings that can include author bylines, article dates, breadcrumbs, and more. Studies consistently show that rich results get significantly higher click-through rates than standard blue links.

Beyond click-through rates, structured data also feeds into Google's Knowledge Graph, helps with voice search answers, and improves how your content appears in Google Discover. For bloggers and content marketers, this is low-hanging fruit that many competitors simply haven't bothered to implement.

The Anatomy of a BlogPosting JSON-LD Schema

Before you generate anything, it helps to understand what a complete BlogPosting schema actually looks like. Here's a well-structured example:

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "How to Make Sourdough Bread at Home",
  "description": "A step-by-step guide to baking perfect sourdough bread, from starter to finished loaf.",
  "image": "https://www.example.com/images/sourdough-bread.jpg",
  "author": {
    "@type": "Person",
    "name": "Jane Smith",
    "url": "https://www.example.com/author/jane-smith"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Blog",
    "logo": {
      "@type": "ImageObject",
      "url": "https://www.example.com/logo.png"
    }
  },
  "datePublished": "2024-03-15T08:00:00+00:00",
  "dateModified": "2024-03-20T10:30:00+00:00",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://www.example.com/blog/sourdough-bread"
  },
  "keywords": "sourdough, bread baking, homemade bread",
  "articleSection": "Food & Cooking",
  "wordCount": 2400
}

Let's break down the key properties:

@context and @type

These two fields are required. @context always points to https://schema.org, and @type tells Google this is specifically a BlogPosting. You could also use Article or NewsArticle depending on your content type, but BlogPosting is the most accurate for personal and professional blogs.

headline

This should match (or closely match) your post's H1 title. Google's guidelines recommend keeping it under 110 characters.

author

The author property can be a Person or an Organization. For most blogs, it's a Person. Including the url property pointing to an author bio page significantly strengthens the signal, especially as Google's E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness) guidelines place more weight on author credibility.

publisher

This is the organization that published the content — typically your blog or company. The logo should be a rectangular image, ideally 60px tall.

datePublished and dateModified

Use ISO 8601 format with timezone information. The dateModified field is particularly important because it signals freshness to search engines, which can help your content maintain rankings over time.

mainEntityOfPage

This connects the schema to the specific URL of your blog post, helping Google understand the canonical location of the content.

How to Generate Schema.org JSON-LD for a Blog Post Using OpDeck

Manually writing JSON-LD from scratch is error-prone. A missing comma, a misquoted URL, or an incorrect property name can invalidate your entire schema block. OpDeck's JSON-LD Structured Data Generator eliminates that friction entirely.

Here's how to use it step by step:

Step 1: Open the JSON-LD Generator

Navigate to OpDeck's JSON-LD Structured Data Generator. No account required — the tool is available immediately.

Step 2: Select Your Schema Type

The tool supports multiple schema types. For a blog post, select BlogPosting or Article from the schema type dropdown. If you're writing news-style content with a publication deadline, NewsArticle might be more appropriate, but for the vast majority of blog content, BlogPosting is the right choice.

Step 3: Fill In Your Post Details

The generator presents you with clearly labeled fields. Work through each one:

  • Headline: Enter your post title exactly as it appears in your H1
  • Description: Write a concise summary (150–300 characters works well here)
  • Image URL: Paste the full URL of your featured image — make sure it's an absolute URL, not a relative path
  • Author Name: Your full name or pen name
  • Author URL: Link to your author bio or About page
  • Publisher Name: Your blog or company name
  • Publisher Logo URL: Full URL to your logo image
  • Date Published: Select from the date picker
  • Date Modified: If you've updated the post, enter the modification date
  • Page URL: The canonical URL of the specific blog post

Step 4: Generate and Copy the Output

Once you've filled in the fields, click Generate. The tool outputs clean, validated JSON-LD that you can copy immediately.

Step 5: Add the Script Tag to Your Blog Post

The generated output needs to be wrapped in a <script> tag and placed in the <head> section of your HTML:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Your Post Title Here",
  ...
}
</script>

Where to Add JSON-LD in Different Blogging Platforms

The process varies slightly depending on where your blog lives.

WordPress

If you're using a theme that doesn't add schema automatically, you have a few options:

Option 1 — Add it to your post template: Edit your single post template (single.php) and add the <script> block inside the <head> tag using wp_head hook.

Option 2 — Use the Custom HTML block: In the Gutenberg editor, add a Custom HTML block and paste your script tag directly. Note that this places it in the body, not the head, but Google accepts JSON-LD in either location.

Option 3 — Add via functions.php:

function add_blog_post_schema() {
    if ( is_single() ) {
        global $post;
        $schema = array(
            '@context' => 'https://schema.org',
            '@type' => 'BlogPosting',
            'headline' => get_the_title(),
            'datePublished' => get_the_date('c'),
            'dateModified' => get_the_modified_date('c'),
            'author' => array(
                '@type' => 'Person',
                'name' => get_the_author()
            )
        );
        echo '<script type="application/ld+json">' . json_encode($schema) . '</script>';
    }
}
add_action('wp_head', 'add_blog_post_schema');

Ghost

In Ghost, go to Settings → Code Injection → Site Header and paste your <script> block there. For post-specific schema, you can use Ghost's handlebars templating to dynamically populate the values.

Webflow

In Webflow, open the page settings for your blog post template, scroll down to Custom Code, and paste the script in the Head Code section.

Static Sites (Hugo, Jekyll, Eleventy)

For static site generators, add the JSON-LD block to your post layout template. You can use template variables to dynamically populate the headline, date, and URL fields. For example, in Hugo:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "{{ .Title }}",
  "datePublished": "{{ .Date.Format "2006-01-02T15:04:05Z07:00" }}",
  "dateModified": "{{ .Lastmod.Format "2006-01-02T15:04:05Z07:00" }}",
  "author": {
    "@type": "Person",
    "name": "{{ .Params.author }}"
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "{{ .Permalink }}"
  }
}
</script>

Validating Your Generated JSON-LD

After adding your schema, always validate it before considering the job done. Google provides two tools for this:

Google's Rich Results Test (search.google.com/test/rich-results): Paste your URL or the raw code snippet. This tool tells you whether your markup is eligible for rich results and flags any errors or warnings.

Schema.org Validator (validator.schema.org): A more technical validator that checks conformance with the full schema.org specification, not just Google's subset.

Common validation errors to watch for:

  • Missing required properties: Google requires headline, image, datePublished, author, and publisher for BlogPosting rich results
  • Relative URLs: All image and page URLs must be absolute (starting with https://)
  • Invalid date formats: Dates must follow ISO 8601 — 2024-03-15T08:00:00+00:00, not March 15, 2024
  • Logo size issues: Publisher logos should be at most 600×60px

Advanced JSON-LD Properties Worth Adding

Once you have the basics working, consider adding these additional properties to make your schema more comprehensive:

keywords

List the primary keywords your post targets. This isn't a direct ranking factor, but it provides additional context:

"keywords": "sourdough bread, bread baking, artisan bread"

articleBody

You can include the full text of your article, though this is rarely done in practice because it's verbose. A better approach is to include a truncated version or skip it entirely.

breadcrumb

Adding breadcrumb schema alongside your BlogPosting schema helps Google display breadcrumb trails in search results:

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://www.example.com"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://www.example.com/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "How to Make Sourdough Bread",
      "item": "https://www.example.com/blog/sourdough-bread"
    }
  ]
}

You can include multiple JSON-LD blocks on the same page — just use separate <script type="application/ld+json"> tags for each one.

speakable

If your blog content is well-suited for voice search (clear, direct answers to questions), the speakable property hints to Google which sections are good candidates for text-to-speech:

"speakable": {
  "@type": "SpeakableSpecification",
  "cssSelector": ["#article-summary", "h1"]
}

Common Mistakes to Avoid When Adding Blog Post Schema

Using the wrong schema type: WebPage is not the right type for a blog post. Use BlogPosting or Article. Using a generic or incorrect type means you won't qualify for article-specific rich results.

Copying schema from another site: If you copy a schema block and forget to update the URLs, dates, or author information, you'll have incorrect structured data pointing to someone else's content. Always generate fresh schema for each post.

Not updating dateModified: When you update an old post (which is great for SEO), remember to update the dateModified field in your schema. This signals freshness to Google.

Inconsistent information: Your schema should match what's visible on the page. If your schema says the author is "Jane Smith" but the byline on the page says "J. Smith," Google may flag this as a mismatch.

Forgetting the image: The image property is required for BlogPosting rich results. It must be a crawlable, indexable image — not one blocked by robots.txt.

Checking If Your Schema Is Indexed

After deploying your JSON-LD, you can check whether Google has processed it using Google Search Console. Go to Enhancements in the left sidebar — if Google has found and processed your article schema, you'll see an "Articles" report there showing valid items, warnings, and errors.

It typically takes a few days to a few weeks for Google to crawl and process newly added structured data, so don't expect immediate results in Search Console.

Conclusion

Generating schema.org JSON-LD for a blog post doesn't have to be a complex, manual process. With the right tool, it takes about two minutes: fill in your post details, generate the output, paste it into your site, and validate. The payoff — richer search results, better click-through rates, and stronger signals to search engines about your content's credibility — is well worth those two minutes per post.

OpDeck's JSON-LD Structured Data Generator makes this process straightforward, producing clean and correctly formatted markup without requiring you to memorize schema.org property names or worry about JSON syntax errors. Whether you're adding structured data to a single post or building it into your publishing workflow, start with OpDeck and get your schema right the first time.

Try these tools

SEO Audit

Comprehensive SEO analysis to improve your search engine rankings

Social Meta Audit

Preview how your URL appears when shared on social media and audit Open Graph tags

JSON-LD Generator

Generate JSON-LD structured data for your web pages using AI

Turbo Subscription

Unlock the full potential of OpDeck

Schedule reports on eligible tasks
Request new tools
Gain API access
Get priority in the queue
Already a subscriber?