A page can have a clear headline, an author name and a publication date, yet still leave you unsure what to put in its structured data. That's the problem I start with when explaining how to generate schema markup. I built Schema Markup Generator and test my tools on a budget Android phone and a laptop. My aim here is to help you turn real page details into JSON-LD, then check what your website actually publishes, without treating a green test result as a promise from Google.
What is schema markup, and what does it do for SEO?
I think of schema markup as a labelled version of information already on your page. A reader can recognise a headline or business address from context. Structured data gives search engines explicit clues about what those details mean. The useful part isn't adding more claims. It's describing the claims you've already made accurately.
Why I usually choose JSON-LD
Google supports JSON-LD, Microdata and RDFa, and recommends JSON-LD when your setup allows it. I prefer JSON-LD because I can review the structured data together rather than trace extra attributes through visible page elements. That makes it easier for me to compare a headline, author and date with the page before publishing.
I keep the promise narrow. Structured data helps describe content and can support eligibility for certain search features. I don't treat it as a direct ranking boost, a guarantee of indexing, or a promise of extra clicks. Google's structured data introduction explains the purpose, while its policies make clear that correct markup doesn't guarantee a rich result.
Tip from me: I start with a page whose content is already accurate. Generating markup for unfinished copy gives me another version of the same information to fix later.
Which schema type should I use for my page?
I choose the type from the page's main purpose, not from the search appearance I'd like to get. If you're describing an article, start there. If you're describing a business location, use the relevant business type. I then check Google's documentation for the particular feature, because Schema.org vocabulary and Google rich-result support aren't the same thing.
| What the page mainly contains | Type to consider | What I check first |
|---|---|---|
| A blog article | Article or BlogPosting | Headline, author, dates and representative image |
| A product | Product | Visible product details and current offers |
| A business location | LocalBusiness | Address, telephone and opening hours |
| Information about an organization | Organization | Name, website and identity details |
| Visible questions and answers | FAQPage | Content match and Google's restricted FAQ eligibility |
Why I don't choose FAQ schema for a search shortcut
Google limits FAQ rich results to well-known, authoritative government and health websites. Its published guidance also says How-to rich results no longer appear in Google Search. So I wouldn't add FAQPage to an ordinary blog expecting an expanded search listing. I can still write useful questions and answers for you without making that promise.
I can describe more than one genuine thing on a page, such as an article and its publisher. But I don't add unrelated types just to make the output longer. My test is simple: can you point to the thing being described, and do its details agree everywhere?
What information should I collect before generating JSON-LD?
Before I open a generator, I gather the page details in one place. This stops me filling a field with a guess just because the field exists. For an article, I begin with the following checklist. For other types, I use the relevant Google feature documentation instead of copying an article's properties into an unsuitable structure.
- I collect the page identity.
- The published page address and the visible headline.
- The representative image address, rather than a placeholder image.
- I collect authorship details.
- The author name shown to readers.
- The publisher details that genuinely apply.
- I check dates against the publishing record.
- The actual publication date.
- A modification date only when it reflects a real update.
Required and recommended don't mean the same thing
Google's Article guide lists no required properties for Article objects. It recommends applicable details such as headline, author, publication date and representative images. I wouldn't turn that into a claim that every article needs an identical set of mandatory fields. Requirements vary by feature, so I check the documentation for the type I'm actually using.
For article dates, I use ISO 8601 date-time formatting and include timezone information as Google recommends. For business or product details, I check the relevant location, currency and opening hours. I also check the page address with URL Validator when needed, while remembering that a valid-looking address doesn't prove the page's information is correct.
How do I generate schema markup with Schema Markup Generator?
I use Schema Markup Generator to create a starting structure rather than type every bracket myself. My workflow starts with the details I collected, not with a desired search feature. If the type or property I need isn't available in the interface, I check the relevant documentation instead of forcing the page into a different type.
- I open Schema Markup Generator and choose the available type that accurately matches my page.
- I enter the real page details into the relevant fields, using the visible headline and author for an article.
- I review the generated JSON-LD, checking every name, address, date and image against my source details.
- I copy the output and check whether my website expects JSON-LD data alone or a complete script element.
- I test the draft, add it through the appropriate publishing method, and then test the live page.
How I read an Article example
In an Article object, I read @context as the vocabulary reference and @type as the kind of thing described. I check headline against the article title. Inside author, I check that the person's name is correct. I check datePublished against the publication record, image against the representative image, and mainEntityOfPage against the page being described.
If I need to inspect the JSON structure more clearly, I use JSON Formatter and Validator. That helps me catch broken syntax, such as a missing comma. It doesn't tell me whether the author is real, the image is appropriate, or the markup meets Google's feature policies. Those still need my review.
How do I add schema markup to a website or WordPress?
Before I paste anything, I check whether the page already has structured data from its theme, SEO plugin or template. Adding a second version of the same article with different dates doesn't make the description clearer. My first choice is to update the system already responsible for that information, if it gives me the control I need.
| Method | When I'd choose it | What I'd check |
|---|---|---|
| Existing SEO plugin | WordPress already generates the relevant schema | Settings, actual output and conflicting plugins |
| Page-specific custom insertion | A particular page needs custom markup | The code appears only on the intended page |
| Site template | Many pages share the same structure | Each page gets its own correct values |
| Manual JSON-LD | I need a carefully controlled custom implementation | Syntax, placement and future maintenance |
For WordPress, I start with the active SEO plugin's schema settings rather than installing another plugin immediately. The exact controls depend on your setup. If custom insertion is necessary, I use a method that preserves script elements and limits the output to the intended page. I don't assume a normal paragraph block will preserve code correctly.
For a custom site, I put JSON-LD in a script element whose type is application/ld+json, in the page head or body. I keep it on the page it describes. If my insertion system already supplies that script wrapper, I don't add another wrapper inside it. Then I inspect the published output rather than trusting the editor preview.
How do I validate schema markup before and after publishing?
I separate testing into different questions. Is the JSON readable? Does the markup use Schema.org vocabulary correctly? Does Google recognise an eligible feature? Does the information match the visible page? One successful test doesn't answer all of those. Google's structured data testing guidance helps explain the difference between its rich-result checks and general schema validation.
- I check JSON syntax first if the output has been edited by hand.
- I use Schema Markup Validator to check the Schema.org markup more generally.
- I use Google's Rich Results Test to check supported Google rich-result features and their issues.
- After publishing, I test the live URL and compare the detected data with the visible page.
- I use URL Inspection to check how Google sees the page when I need to investigate access or indexing.
How I handle errors and warnings
I read the affected property and the feature documentation before changing anything. A syntax error can stop data from being read. A missing required property can affect eligibility for a particular feature. A warning about a recommended property needs context. I add the information if it's accurate and applicable, not simply to remove a warning.
Tip from me: I always test the published URL after testing pasted code. The pasted draft can't reveal a script removed by the CMS or conflicting markup added by a template.
Which schema markup mistakes should I avoid?
The mistakes I pay most attention to are content mismatches. Perfectly readable JSON can still describe something that isn't on the page. Google says structured data should reflect visible content, and misleading markup can prevent rich-result eligibility or lead to a manual action. I treat that as a reason to simplify, not to hide more detail in code.
- I remove sample names, placeholder image addresses and invented values before publishing.
- I don't copy one page's headline, dates or address across unrelated pages.
- I check themes, plugins and custom code for conflicting descriptions of the same thing.
- I don't add ratings or reviews merely because a generator offers those fields.
- I don't label a routine page refresh as a new publication just to change its date.
Review markup deserves particular care. Google requires the represented review content and ratings to be available to readers, and says not to aggregate reviews from other websites. Its rules also make self-serving local business or organization reviews ineligible for the review-star feature when the reviewed entity controls those reviews on its own site.
Why is valid schema not showing as a rich result?
When markup validates but the search result looks unchanged, I don't keep adding properties at random. First I check whether the type supports the Google feature I'm expecting. Then I check the feature's requirements and policies. A Schema.org-valid description can exist without corresponding to a Google rich result at all.
Next I check access. Google says pages need to be accessible for rich-result eligibility, without robots.txt blocking, noindex or access controls preventing the necessary access or indexing. I review those settings carefully rather than removing restrictions blindly. Some pages are intentionally private, and making them public just to chase a search feature would be the wrong fix.
I also compare the tested URL with the actual page I want indexed and inspect what Google can see. If I need to review robots rules, I use Robots.txt Generator as a starting point, not as permission to overwrite existing rules. Even after the checks pass, Google's policies still say rich-result display isn't guaranteed.
How do I keep schema markup accurate after launch?
I treat structured data as part of the page, not a separate task that's finished forever. Whenever the visible information changes, I check the corresponding markup. This matters especially for prices, availability, opening hours and dates. A structure that passed validation earlier can become misleading without any brackets or commas changing.
- When I edit an article, I check its headline, author, image and applicable dates.
- When business details change, I check the address, telephone, location and opening hours.
- When a theme, plugin or template changes, I retest the live output for missing or conflicting markup.
- When I revisit a feature, I check Google's current documentation rather than rely on an old promise.
My preferred setup keeps page content and structured data tied to the same source wherever practical. That reduces the chance of updating a visible price while forgetting its markup. I still review the final page, because automation can repeat an incorrect value just as consistently as a correct one. Fewer manual copies give me fewer places to miss an update.
Questions people ask
How do I create schema markup without coding?
I start with Schema Markup Generator, choose a suitable available type, and enter accurate page details. You don't need to write the starting JSON-LD by hand. But I still review the output, check existing website markup, and validate the published page. A generator saves typing, not the responsibility to check facts.
What is the easiest way to add schema markup to WordPress?
I first check whether the active SEO plugin already generates the type I need. Adjusting that output is often simpler than adding a separate copy. If custom markup is necessary, I choose a page-specific insertion method and test the result. The easiest safe option depends on your theme, editor and plugins.
Is JSON-LD better than Microdata or RDFa?
I usually choose JSON-LD because I find a separate block easier to review and maintain. Google supports all three formats and recommends JSON-LD when the site's setup allows it. I wouldn't replace working markup purely for appearance, though. Accuracy, content matching and a maintainable implementation matter more than my formatting preference.
Where do I put JSON-LD on a webpage?
I put JSON-LD in a script element with the type application/ld+json, in the head or body of the page it describes. Your CMS may supply the script wrapper for you, so I check its expected input first. After publishing, I test the live page to confirm the data survived insertion.
How do I test whether my schema markup is valid?
I use Schema Markup Validator for general Schema.org checks and Google's Rich Results Test for supported Google rich-result features. If I've edited the data manually, I check JSON syntax too. Then I compare the detected details with the visible page, because neither a syntax check nor a feature test can establish every fact.
Can I add more than one schema type to a page?
I can describe multiple genuine things on a page, such as an article and its publisher. I make sure their details agree and avoid conflicting copies from plugins or custom code. I don't add types simply to increase the amount of markup. Each description should have a clear reason to be there.
What to do next
I would start with one finished page, not the whole site. Collect its visible details, check whether your CMS already describes it, and open Schema Markup Generator to create the appropriate starting JSON-LD. Review every value, test the draft, and add it through the system you'll maintain. Then test the live URL with both the Schema.org and Google checks. If the markup is accurate but no rich result appears, don't invent extra information to chase one. Keep the page useful, keep its structured data current, and make validation part of your next content or template update.