Schema.org on a Corporate Site: Organization, Service and Article Markup

JSON-LD schema on a corporate site: Organization, WebSite, Service, Article and BreadcrumbList examples, an entity graph with @id, plugin conflicts and validation.
Technical summary
Technology
Schema.org, JSON-LD, Google Rich Results Test, Schema Markup Validator, Yoast SEO, Rank Math
Topic
Structuring structured data on a corporate services site
Level
Intermediate
Prerequisites
  • Basic HTML and JSON knowledge
  • Access to the site’s template structure (header, single post, page)
  • Access to Google Search Console
In this article7 sections

When we open the source of a corporate site and count the JSON-LD blocks, we usually see the same picture: the theme outputs one Organization, the SEO plugin a second and the page builder a third. Article nodes aren’t connected to any publisher, and the author field says “admin”. A search engine can’t work out who the company is from this output. This guide explains how to build a single, consistent schema map with JSON-LD on a B2B services site, which types actually produce rich results today and how to validate the output.

What structured data provides, and what it doesn’t

Set expectations correctly from the start. Google states clearly that structured data isn’t a general ranking factor. It provides three things: unambiguous identification of the content type and entities (company, author, service), rich result eligibility for certain types, and identity signals that can be used in areas such as the knowledge panel.

The rich result side has narrowed over time. In 2023 Google limited FAQ rich results to authoritative government and health sites and removed HowTo rich results. The sitelinks search box was later dropped from the results page too. On a corporate services site, the real return on schema isn’t a starred snippet but a consistent entity identity. Check which types are currently supported each time in Google’s structured data gallery. This list changes.

What schema doesn’t do is also clear: it doesn’t solve indexing problems, doesn’t strengthen weak content and isn’t a way to “add” information that isn’t visible on the page. According to Google’s guidelines, markup must represent the content the user sees on the page; schema written for hidden content can be subject to a manual action. Which pages get indexed and which stay out is a separate job, managed with canonical, noindex and sitemap signals. Schema doesn’t replace these signals.

A schema map for a corporate site

Before writing a single line of JSON-LD, draw up the map: which template will produce which type, and which entities will stay common across the whole site. For a typical corporate B2B services site, this table is the starting point:

Page type Main type Connected nodes Google rich result
Home page WebPage Organization, WebSite Logo/identity signal
Service page WebPage + Service provider → Organization None
Blog/guide post BlogPosting or Article author, publisher, BreadcrumbList Article features
Contact page ContactPage Organization (contactPoint, address) None
All inner pages BreadcrumbList WebPage Breadcrumb display (Google stopped showing it on mobile in 2025; it continues on desktop)

The mistake we see most often in the field at a services company that doesn’t sell products is adding Product, Offer or AggregateRating types just “to get stars in search results”. Reviews about your own services published on your own site (self-serving reviews) aren’t eligible to show stars under Google’s review snippet policy. No stars appear. The risk remains.

Organization and WebSite markup

The Organization node is the site’s identity card; it’s defined once, with a fixed @id. It’s usually output in full on the home page, and other pages reference it with the same @id. If there are sub-brands or subdomains in a network, keep the parent organization single instead of generating a separate Organization for each, and define the subsites as WebSite. In most structures, this is the right model.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://www.example.com/#organization",
      "name": "Example IT Ltd.",
      "url": "https://www.example.com/",
      "logo": {
        "@type": "ImageObject",
        "url": "https://www.example.com/assets/logo-512.png"
      },
      "sameAs": [
        "https://www.linkedin.com/company/example-it"
      ],
      "contactPoint": {
        "@type": "ContactPoint",
        "contactType": "customer support",
        "telephone": "+90-212-000-00-00",
        "availableLanguage": ["tr", "en"]
      }
    },
    {
      "@type": "WebSite",
      "@id": "https://www.example.com/#website",
      "url": "https://www.example.com/",
      "name": "Example IT",
      "inLanguage": "en",
      "publisher": { "@id": "https://www.example.com/#organization" }
    }
  ]
}

Problems in this block most often arise in these three places:

  • logo must be a crawlable URL and must not be blocked by robots.txt. According to Google’s documentation, it should be at least 112×112 pixels and look right on a plain white background.
  • sameAs contains only official profiles belonging to the organization. Employees’ personal accounts don’t go here.
  • Fields such as address, tax number and phone must be identical to the contact information on the site. When the phone number changes, the contact page is updated and the schema is forgotten; inconsistency most often starts here.

Service and Article pages

Service pages

The Service type doesn’t produce a rich result in Google. Still, it makes clear that the page isn’t a product listing or blog post but a service offered by a specific organization. Linking the provider field to the Organization with @id, giving the service region with areaServed and the category with serviceType is enough. If you don’t publish a price list, don’t add offers.

{
  "@context": "https://schema.org",
  "@type": "Service",
  "@id": "https://www.example.com/services/technical-seo/#service",
  "name": "Technical SEO and Site Architecture",
  "serviceType": "Technical SEO consulting",
  "provider": { "@id": "https://www.example.com/#organization" },
  "areaServed": { "@type": "Country", "name": "Türkiye" },
  "mainEntityOfPage": { "@id": "https://www.example.com/services/technical-seo/#webpage" }
}

Guides and blog posts

For posts, BlogPosting (a subtype of Article) can be used. Google’s Article documentation has no required fields; the recommended fields are headline, image, datePublished, dateModified and author. Two fields keep causing problems in audits:

  • author: If the author is a person, it’s given as type Person, with their name and author page url. Writing the company name as a Person or leaving the field as “Admin” is a common mistake. If content is published in the organization’s name, Organization can be used as the author.
  • dateModified: Updated only when there’s a meaningful change in the content. Plugin settings that refresh the date on every cache purge or template change reduce trustworthiness.

BreadcrumbList must be the same as the visible breadcrumb on the page. For each ListItem, position, name and, except for the last item, an item URL are given. The source of the breadcrumb is the site’s category structure. If that structure is broken, the schema comes out broken too; that’s why corporate site information architecture work comes before schema.

Building an entity graph with @id

When you connect nodes with @id inside a single @graph instead of disconnected JSON-LD blocks, the search engine doesn’t have to guess that “this post’s publisher is the same entity as the organization on the home page”. The established rule is to generate the @id by adding a fragment identifier to the relevant URL: /#organization, /#website, <page-url>#webpage, <page-url>#breadcrumb.

The graph on a single post page carries these relationships:

  1. WebPage → isPartOf → WebSite
  2. WebPage → breadcrumb → BreadcrumbList
  3. BlogPosting → mainEntityOfPage → WebPage
  4. BlogPosting → publisher → Organization (an @id reference only)
  5. BlogPosting → author → Person (with its own @id)

Although @id is in URL format, it doesn’t need to open in a browser; it’s an identifier. There’s one rule: the same value for the same entity everywhere on the site. Differences in http/https, with/without www or a trailing slash are read as separate entities. A single character is enough. In a network of sites, for example subdomains in a multisite structure, all sites should reference the parent organization with the same @id.

On sites generated with JavaScript, it’s preferable for the schema to be in the initial HTML response. Google can also process JSON-LD added later on the client side, but dependence on rendering adds delay and a new point of failure. The general framework for this topic is in the React, SSR, SSG and technical SEO article.

Validation and plugin conflicts

Validation answers two separate questions and needs two separate tools:

Tool Question it answers Limit
Rich Results Test Is the page eligible for a rich result Google supports? Doesn’t report unsupported types (such as Service)
Schema Markup Validator (validator.schema.org) Is the markup valid according to the schema.org vocabulary? Gives no information on Google eligibility
Search Console enhancement reports Which templates across the site have errors/warnings? Only the types Google reports, with a delay

Plugin conflicts in WordPress

Plugins such as Yoast SEO and Rank Math generate one @graph per page on WordPress sites. The problem starts when the theme, the page builder or a second plugin adds its own Organization or Article block to the same page. The first thing to do in the console is count the JSON-LD types in the page source:

curl -s https://www.example.com/guides/example-post/ \
  | grep -o '"@type":"[A-Za-z]*"' | sort | uniq -c

This command only works on whitespace-free (minified) JSON output; for indented output, widen the grep pattern to '"@type": *"[A-Za-z]*"'. If you see two Organization or two Article on the same page, find their source. The practical order of solutions is: turn off the theme’s or page builder’s schema output, add the missing fields to the same graph through the SEO plugin’s settings or filters, and if an extra block is unavoidable, write it to reference the plugin’s @id values.

Checklist

  • A single Organization with a fixed @id, and contact information matching the page.
  • In every post, author is a real person or organization; not “admin”.
  • datePublished and dateModified are in ISO 8601 format and include a time zone.
  • BreadcrumbList is identical to the visible breadcrumb.
  • No invisible content or reviews written about yourself are marked up.
  • No duplicate nodes of the same type per page.
  • Search Console enhancement reports are reviewed monthly.

A schema map isn’t built on its own; it’s designed at the same table as the site architecture and indexing signals. We handle this work as part of technical SEO and site architecture.

Frequently asked questions

Does schema markup directly raise rankings?

No. Google states that it doesn’t use structured data as a general ranking signal. Its contribution is through the content being understood correctly and rich result eligibility for suitable types; it may affect click-through rate indirectly.

Should I remove FAQPage markup?

It’s not required. Valid FAQPage markup that matches the visible content on the page exactly does no harm. But since 2023 Google has shown FAQ rich results only on authoritative government and health sites, so don’t expect a visual gain on a corporate services site.

Is there a Google rich result for the Service type?

No, Service isn’t among the rich result types Google supports. Still, it’s a valid schema.org type; it makes who provides the service and in which region machine-readable and contributes to the consistency of the entity graph.

If an SEO plugin already generates schema, do I need to add JSON-LD separately?

First look at the graph the plugin generates. Adding missing fields to the same graph through the plugin’s filters or settings is cleaner than outputting a second, independent JSON-LD block. If two separate Organization nodes have been created, make their @id values match or remove one.

Support

Contact us for support or a discovery session on this topic.

Contact form
[email protected]

Eretek Web

We build and maintain corporate websites, WordPress and CMS platforms, intranet and SharePoint portals, document management, and form and approval workflows, and keep them secure and up to date.

Knowledge Center

Other articles