Dataset Schema

TL;DR — Dataset schemaDataset schema (schema.org/Dataset) is structured data that marks up a data collection so it can surface in Google's dedicated Dataset Search tool — a separate destination from the main web-search results, not a mainstream rich snippet. is code you add to a page that publishes a collection of data — research data, government/civic data, a machine-learning training set — so a search engine understands what the dataset is. But here’s the catch most people miss: it does not get you the fancy listings you see on normal Google searches. It feeds a separate tool called Google Dataset Search (datasetsearch.research.google.com), a different site Google built for researchers and data scientists. If you don’t literally publish data, this markup isn’t for you.

What Dataset schema is

When you land on a page hosting a dataset — a CSV of rainfall readings, a public health data table, an ML training set — you can read the title, spot the license, see who created it. A search engine sees plain text and has to guess. Dataset schema spells it out in code, using the shared schema.org vocabulary: this is the dataset’s name, this is a description of what it contains, this is the creator, this is the license, these are the download formats.

It’s almost always written as JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. — a small block of code that sits in the page without changing how the page looks.

The one thing to understand before anything else

Most schema typesSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. earn you a rich result in ordinary Google search — the star ratings, the FAQ dropdowns, the recipe cards. Dataset schema does not. Its entire payoff is a separate Google product: Dataset Search, a dedicated tool at a different web address that indexes datasets from across the web. Everyday searchers typing a question into Google never see it. So don’t add Dataset schema expecting your page to suddenly look richer in normal results — that’s not what it does.

What you actually need

Only two properties are truly required:

• name — what the dataset is called. Make it specific (more on why below).
• description — a plain-language summary of the data, between 50 and 5,000 characters.

Beyond that, a few extras carry real weight for this particular audience:

• license — the reuse terms, as a clean URL. Researchers evaluating your dataset want to know the license before they invest time in it — though the markup itself is a pointer to the terms, not a substitute for reading them.
• isAccessibleForFreeA paywall restricts some or all of a page behind payment, subscription, or registration. Google's supported way to keep that content indexable is flexible sampling: mark the gated part with structured data (isAccessibleForFree, cssSelector) so Googlebot can still read it — which is why it doesn't count as cloaking. — whether it’s free to access.
• creator, keywords, and the coverage of the data (where and when it was collected).

Who should bother

Honestly? A narrow group: research institutions, government and university open-data portals, machine-learning dataset hosts (think Kaggle-style sites), and scientific journals that publish supporting data. For them it’s genuinely valuable. For a typical business or blog with no literal dataset to share, it’s the wrong tool — and adding it won’t help your normal search visibility one bit.

Want the required-vs-recommended property detail, the “duplicate name” pitfall Google specifically warns about, and a full JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. example? Switch to the Advanced tab.

TL;DR — schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./Dataset markup (usually JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.) makes a data-collection page discoverable in Google Dataset Search (datasetsearch.research.google.com). A November 5, 2025 Google Search Central documentation update explicitly scoped Dataset structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. to Dataset Search — not mainstream Google Search — so treat it as a separate destination, not a general-SERP rich snippet. Google’s current Dataset Search profile requires description (50–5000 chars, of which Dataset Search reads only the first 5000) and name; license and isAccessibleForFree matter more here than on most CreativeWork types because Dataset Search users are weighing reuse — though license, access rights, and legal rights are distinct layers, and markup doesn’t decide legal reuse (not legal advice). Google explicitly calls out duplicate generic names (many undisambiguated “Snow depth” datasets) and incomplete license URLs as real-world failure modes. This is a niche play for life-sciences, social-sciences, ML, and civic/government data publishers — not a general SEO ranking tactic. If your site has no literal dataset, this type isn’t for you, and no amount of markup changes that.

What Dataset schema actually does — the Dataset Search distinction

This is the framing that most competitor content gets wrong, so I’ll be blunt: Dataset schemaDataset schema (schema.org/Dataset) is structured data that marks up a data collection so it can surface in Google's dedicated Dataset Search tool — a separate destination from the main web-search results, not a mainstream rich snippet. does not feed a mainstream Google web-search rich result. It feeds Google Dataset Search, a dedicated tool at its own address (datasetsearch.research.google.com), separate from the main SERP. Google made this explicit rather than implicit: a November 5, 2025 entry in Google Search Central’s documentation-updates log clarified that Dataset structured data is used only by Dataset Search, not by Google Search itself. Dataset Search is the tool researchers, data scientists, and analysts go to when they need to find data — and Dataset schema is the signal that gets your dataset into that indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed.. I won’t call Dataset a mainstream rich result anywhere else on this page; the distinction above is the one that matters.

Google’s own framing is a discovery-tool framing, not a rich-snippet one: “Datasets are easier to find in the Dataset Search tool when you provide supporting information such as their name, description, creator and distribution formats as structured data.” Read that carefully — “easier to find in the Dataset Search tool,” not “gets a rich result in Search.” That distinction is the whole point of this article.

Required vs. recommended properties

These are Google’s current Dataset Search consumer profile requirements — narrower than the general schema.org/Dataset vocabulary, and specific to what Google’s tool checks for. Checked against Google’s documentation as of 2026-07-16.

Required by Google’s Dataset Search profile (both, or you’re not eligible):

• name — the dataset’s title.
• description — 50 to 5,000 characters. This length window is a hard constraint people trip over: a one-line description under 50 characters fails validation, and an enormous data dictionary over 5,000 characters gets rejected. Beyond the ceiling, Dataset Search reads only the first 5,000 characters of textual properties like this one — content past that point isn’t consumed, so don’t bury anything load-bearing at the end.

Recommended by Google’s profile — and the ones that matter more here than in most CreativeWork types:

• license — the reuse terms, ideally as a clean, complete URL to the license. Dataset Search users are often trying to gauge whether the data looks reusable for their purposes, so an incomplete or missing license is a real cost, not a cosmetic one. (More on why “license” isn’t the whole legal picture below.)
• isAccessibleForFree — whether access is free. Same reasoning: reuse evaluation.
• creator, funder, citation — provenance and how to cite it.
• identifier — a DOI or other persistent ID.
• keywords, variableMeasured — what the data covers and measures.
• spatialCoverage, temporalCoverage — the geographic and time span of the data.
• distribution — the actual download/access formats (DataDownload objects with contentUrl and encodingFormat).
• hasPart / isPartOf, sameAs, measurementTechnique, alternateName, version, url.

Common mistakes Google specifically flags

Google’s docs call out concrete, real-world failure modes — these aren’t hypotheticals:

• Duplicate / generic dataset names. The canonical example is many datasets all named “Snow depth” from different providers with no disambiguation. At scale this makes datasets indistinguishable in Dataset Search. name uniqueness matters more than for almost any other schema type — bake the provider, region, or time range into the name.
• Incomplete license URLs. A truncated or non-resolving license link undermines the single field your audience most wants to check.
• Unexpected csvw:Table values. Malformed CSV-on-the-Web metadata is a documented source of errors, though the DCAT documentation notes this specific warning can be ignored under the condition it describes — check your own case against the docs before assuming it applies.

License, access rights, and what the markup doesn’t decide

This is a place I want to be more careful than most schema explainers are. License, access rights, and other-rights metadata are distinct layers, not one field standing in for all of them — that distinction comes from DCAT (the Data Catalog Vocabulary that schema.org/Dataset interoperates with), not just from schema.org itself:

• license describes the reuse terms Google’s Dataset Search profile checks for.
• Access rights (who can get the data at all) and other rights (attribution, restrictions beyond the license) are separate concerns DCAT tracks alongside license.
• A dataset can have a license at the dataset level and a different one at the distribution level (see the Dataset-vs-distribution model below) — DCAT explicitly warns that conflicting dataset- and distribution-level license declarations can mislead whoever’s trying to evaluate reuse. If you publish multiple distributions, make sure their licenses agree with the dataset-level license or are deliberately, clearly scoped differently.

None of this is legal advice, and the markup itself doesn’t decide legal reuse rights. Adding a license property is a machine-readable pointer to the terms — it doesn’t grant a license, waive rights, or resolve a conflicting claim. If reuse terms genuinely matter for a dataset (they usually do, for this audience), get the license text right and, where it’s ambiguous or high-stakes, point users to actual legal guidance rather than relying on the schema field alone.

Who should actually implement this

I want to be honest about fit rather than overselling a niche type:

Good fit:

• Research institutions and .edu publishing study data.
• Government / civic open-data portals (.gov and equivalents).
• ML / data-science dataset hosting — Kaggle-style repositories.
• Scientific journals with supplementary datasets behind papers.
• Science-journalism sites publishing the data behind a story.

Poor fit:

• Typical commercial content sites, blogs, or stores with no literal dataset to publish. There is no version of this that helps your ordinary search traffic, and marking up a random downloadable PDF or spreadsheet as a Dataset is misuse — Google’s guidance implies a real, structured data collection, not any arbitrary downloadable file.

The purpose, in Google’s own words, is broad within research and data: “The purpose of this markup is to improve discovery of datasets from fields such as life sciences, social sciences, machine learning, civic and government data, and more.” Note that framing kills a common myth — this is not “only for government data.” It spans life sciences, social sciences, ML, and civic/government data alike. But it’s still scoped to actual datasets.

Where Dataset sits in the schema family

Dataset lives in the Creative Works family alongside siblings like Article, Book, and the media-object types — it’s the CreativeWork subtype for structured data collections specifically. If what you’re publishing is prose, an Article; if it’s a book, Book; if it’s a queryable/downloadable data collection, Dataset. For where all of this fits in the broader picture, the Schema MarkupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. and Structured Data hubs this article nests under are the place to start.

The Dataset → distribution → version model

Worth understanding conceptually before you write the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.: a dataset is the thing being described — the conceptual collection. A distribution is one accessible representation of it — a CSV export, a JSON API, a ZIP archive. One dataset can have several distributions. In schema.org terms, DataDownload (used inside the distribution property) is the equivalent of DCAT’s dcat:Distribution — same relationship, different vocabulary. That’s why license and access information can differ by distribution, not just by dataset, and why the conflict warning in the section above matters.

On top of that, DCAT 3 (a W3C Recommendation) adds formal versioning and dataset-series semantics — useful once you’re publishing updated releases of the same underlying dataset over time — while staying backward-compatible with DCAT 2. If you’re not already using those features, DCAT 2-style metadata doesn’t need an upgrade just because DCAT 3 exists.

AI summary

A condensed take on the Advanced version:

• What it is: schema.org/Dataset markup (usually JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.) that describes a data collection — research data, government/civic data, ML training sets — so it can be discovered.
• The single most important point: it does not produce a mainstream Google web-search rich snippet. A November 5, 2025 Google Search Central documentation update explicitly scoped Dataset structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. to Google Dataset Search (datasetsearch.research.google.com), a separate destination Google built for researchers and data scientists — not mainstream Google Search.
• Required properties (Google’s Dataset Search profile): only two — description (50–5000 characters, of which Dataset Search reads only the first 5000) and name. A description under 50 or over 5,000 characters fails. Checked as of 2026-07-16.
• Recommended, but load-bearing here: license and isAccessibleForFree matter more than in most CreativeWork types because Dataset Search users are weighing reuse — though license, access rights, and legal rights are distinct layers per DCAT, and the markup doesn’t decide legal reuse rights (not legal advice). Also creator, identifier, keywords, spatialCoverage, temporalCoverage, variableMeasured, distribution.
• Dataset vs. distribution: a dataset is the described collection; a distribution (DataDownload) is one accessible representation of it — same relationship as DCAT’s dcat:Distribution. DCAT 3 adds versioning/series semantics on top, backward-compatible with DCAT 2.
• Common mistakes Google flags: duplicate/generic names (many “Snow depth” datasets undisambiguated — name uniqueness is critical), incomplete license URLs, unexpected csvw:Table values.
• Who should use it: research institutions, .gov/.edu open-data portals, Kaggle-style ML dataset hosts, journals with supplementary data. Not typical commercial sites with no literal dataset — and marking up an arbitrary downloadable file as a Dataset is misuse.
• Myth corrected: it is not “only for government data” — Google’s own framing spans life sciences, social sciences, ML, and civic/government data. And it is not a general SEO ranking or rich-result tactic; it’s a niche distribution play for a specific audience.

Official documentation

Primary-source documentation from the search engines.

Google — structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding.

• Dataset structured data — the authoritative reference: required name/description, the full recommended-property list, and the common-mistakes guidance (duplicate names, license URLs, csvw:Table).
• Structured data search gallery — the full catalog of Google’s structured-data features, showing where Dataset (and its separate Dataset Search destination) sits relative to the on-SERP rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show..
• Rich Results Test — Google explicitly points Dataset publishers here, but treat it as a check of Google-supported feature eligibility and Dataset-specific issues, not a universal schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. validator, and not proof that a Dataset Search listing will actually appear.
• Google Dataset Search — the actual destination this markup feeds; browse it to see what a well-marked-up dataset looks like as a result.

Bing / Microsoft

• Marking up your site with structured data — Bing’s general structured-data support (schema.org, JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. recommended).

Quotes from the source

On-the-record statements from Google. Where a source page exposes the text, the link is a deep link that jumps to the quoted passage.

Google docs — what the markup is for

• “Datasets are easier to find in the Dataset Search tool when you provide supporting information such as their name, description, creator and distribution formats as structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding..” Jump to quote
• “The purpose of this markup is to improve discovery of datasets from fields such as life sciences, social sciences, machine learning, civic and government data, and more.” Jump to quote

Dataset schema myths and mistakes to avoid

Myth: “Dataset schemaDataset schema (schema.org/Dataset) is structured data that marks up a data collection so it can surface in Google's dedicated Dataset Search tool — a separate destination from the main web-search results, not a mainstream rich snippet. gets me a rich snippet in regular Google search results.” False — and this is the mistake that sends the wrong people down this path. Dataset schema feeds Google Dataset Search (datasetsearch.research.google.com), a separate tool most everyday searchers never open. It does not enhance how your page looks in the mainstream SERP. If a general-search rich result is what you’re after, Dataset is the wrong type entirely.

Myth: “Dataset schema is only for government data.” False. Google’s own framing is explicit that it covers “life sciences, social sciences, machine learning, civic and government data, and more.” Government open data is one important use case, not the boundary.

Myth: “Any downloadable file on my site is a dataset.” No. A random PDF, a marketing spreadsheet, or a downloadable brochure is not a Dataset. Google’s guidance implies a real, structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. collection. Marking up arbitrary downloads as datasets is misuse and won’t help you.

Mistake: duplicate or generic name values. Google specifically flags this — many undisambiguated “Snow depth” datasets from different providers become indistinguishable. Uniqueness in name matters more here than in almost any other schema type; encode the provider, region, or time range.

Mistake: a description outside the 50–5,000 character window. A one-liner under 50 characters and a giant data dictionary over 5,000 both fail validation. Write a real, human summary in that range.

Mistake: incomplete or non-resolving license URLs. The license is the field your research audience most wants to check before reusing the data. A truncated or broken license link undermines the single most valuable recommended property for this type.

Mistake: overselling it to a client who has no dataset. If the site publishes prose, products, or services — not literal data collections — Dataset schema does nothing for it. Recommending it outside its real use case is the most common way this type gets misapplied.

Dataset schema cheat sheet

The one framing to never forget

Dataset schemaDataset schema (schema.org/Dataset) is structured data that marks up a data collection so it can surface in Google's dedicated Dataset Search tool — a separate destination from the main web-search results, not a mainstream rich snippet. → Google Dataset Search (datasetsearch.research.google.com), a separate tool. Not a mainstream web-search rich snippet.

Required (only two)

Recommended — the load-bearing ones for this audience

Common mistakes Google flags

• Duplicate / generic name values (the “Snow depth” problem).
• Incomplete or non-resolving license URLs.
• Unexpected csvw:Table values.
• description under 50 or over 5,000 characters.

Fit check

Fast facts

• Format: JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. (recommended).
• Fields covered: life sciences, social sciences, ML, civic/government — not government-only.
• Payoff surface: Dataset Search, not the main SERP.
• No Bing equivalent to Dataset Search turned up in this research.
• Nov 5, 2025: Google documentation explicitly clarified Dataset is Dataset-Search-only.

Should I use Dataset schema at all?

Work down the questions honestly — this type is easy to misapply.

1. Does the page publish a real, structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. collection (research data, civic/government data, an ML training set, journal supplementary data)?

• No — it’s prose, a product, a service, or an arbitrary downloadable file → Dataset schemaDataset schema (schema.org/Dataset) is structured data that marks up a data collection so it can surface in Google's dedicated Dataset Search tool — a separate destination from the main web-search results, not a mainstream rich snippet. is not for you. Use the right CreativeWork type (Article for prose, Book for a book) or none. Don’t force it.
• Yes → continue.

2. Are you hoping this gets you a richer listing in normal Google search?

• Yes → reset your expectations. Dataset schema does not do that. It feeds Dataset Search, a separate tool. If a mainstream rich result is the goal, you’re looking at the wrong schema type.
• No — you want your dataset discoverable by researchers/data scientists in Dataset Search → continue; this is exactly the right play.

3. Do you have the two required properties?

• name that is specific and unique (not a generic repeat), and
• description between 50 and 5,000 characters.
• Missing either or out of range → fix that first; you’re not eligible otherwise.

4. Can you add the reuse-critical recommended fields?

• Add license (complete URL) and isAccessibleForFree — for this audience these are near-essential, since users are deciding whether they can legally reuse the data. Then layer in creator, identifier, keywords, spatialCoverage, temporalCoverage, and distribution.

5. Before you ship:

• Validate the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., confirm the description is in range, confirm the name isn’t a generic duplicate, and confirm the license URL resolves.
• Then check whether the dataset actually appears in Google Dataset Search — that’s the destination, not the main SERP.

Rule of thumb: if you can’t point at a literal dataset on the page, stop — this type isn’t the one you want.

Clean vs. broken Dataset JSON-LD

Quick model before the code: the Dataset node below describes the collection itself; the single object inside distribution is one accessible representation of it (schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor.’s DataDownload, the equivalent of DCAT’s dcat:Distribution). A real dataset can have several distributions — one CSV, one API endpoint, one ZIP — each potentially with its own contentUrl and encodingFormat. See the Advanced tab for the fuller Dataset → distribution → version model, including why license can differ by distribution.

A clean, well-formed Dataset snippet

A specific name, a description comfortably in the 50–5,000 range, a complete license URL, free-access flag, coverage, and a real distribution:

{
  "@context": "https://schema.org/",
  "@type": "Dataset",
  "name": "NOAA Daily Snow Depth — Colorado Front Range, 2010–2024",
  "description": "Daily snow depth measurements in centimeters from 42 automated weather stations across Colorado's Front Range, collected between January 2010 and December 2024. Includes station identifiers, elevation, latitude/longitude, and quality-control flags for each reading.",
  "url": "https://example.org/datasets/co-front-range-snow-depth",
  "keywords": ["snow depth", "Colorado", "Front Range", "climate", "weather stations"],
  "creator": {
    "@type": "Organization",
    "name": "Example Climate Research Institute",
    "url": "https://example.org"
  },
  "license": "https://creativecommons.org/licenses/by/4.0/",
  "isAccessibleForFree": true,
  "identifier": "https://doi.org/10.1234/co-frontrange-snow-2024",
  "temporalCoverage": "2010-01-01/2024-12-31",
  "spatialCoverage": {
    "@type": "Place",
    "name": "Colorado Front Range, USA"
  },
  "variableMeasured": "snow depth (cm)",
  "distribution": [
    {
      "@type": "DataDownload",
      "encodingFormat": "text/csv",
      "contentUrl": "https://example.org/datasets/co-front-range-snow-depth.csv"
    }
  ]
}

The same dataset, broken

Every line flagged below is a real, common Dataset failure mode:

{
  "@context": "https://schema.org/",
  "@type": "Dataset",
  "name": "Snow depth",
  "description": "Snow data.",
  "license": "creativecommons.org/licenses/by",
  "isAccessibleForFree": "yes"
}

What’s wrong:

• name: "Snow depth" — the exact generic-duplicate problem Google calls out. Hundreds of “Snow depth” datasets exist; nothing distinguishes yours. Encode the provider, region, and time range.
• description: "Snow data." — far under the 50-character minimum. Write a real summary in the 50–5,000 window.
• license: "creativecommons.org/licenses/by" — an incomplete, non-resolving URL (no scheme, no version). Use a full URL like https://creativecommons.org/licenses/by/4.0/.
• isAccessibleForFree: "yes" — should be a boolean true/false, not a string.
• No creator, distribution, or coverage — technically still valid with just name + a fixed description, but this dataset gives Dataset Search users almost nothing to evaluate, cite, or reuse.

Where the payoff shows up

Remember: a clean version of the first snippet doesn’t change how your page looks in ordinary Google search. Its success shows up in Google Dataset Search — search there for the dataset after it’s indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. to confirm it surfaced.

Tools for writing, validating, and testing Dataset markup

I’d start with my own Schema Markup Validator before touching anything else. Paste your Dataset JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. in and it runs severity-tiered structured-data checks against the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. vocabulary and Google’s rich-result requirements, catches cross-block @id graph problems, and hands back a corrected, copy-pasteable JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. block — useful for catching exactly the failure modes this article covers, like a description outside the 50–5,000 character window or a malformed license string.

The Rich-Result Eligibility Checker is the second stop, and it’s the one built specifically for the “am I actually eligible” question. Paste JSON-LD, paste a full HTML page, or fetch a live URL, and it tells you per type whether the page qualifies — for Dataset specifically it checks the two required properties (name, description) and flags the recommended ones (creator, license, distribution.contentUrl, identifier, sameAs, temporalCoverage, spatialCoverage, variableMeasured, keywords, url) that matter most to a Dataset Search user deciding whether to reuse your data. It also carries the same honest framing this article does: Dataset surfaces in Google Dataset Search rather than as a standard on-SERP rich result, so don’t expect a mainstream-search preview card.

If you’re building the markup from scratch rather than fixing existing markup, the Schema Markup Generator covers Dataset among its full 921 vendored schema.org types — browse the inherited properties and expected value ranges, and export the JSON-LD in whichever of its six output formats you need. It won’t hold your hand through the Dataset-specific gotchas the way the eligibility checker does, but it’s the faster way to get a structurally correct starting point before you run it through the other two tools.

My suggested order for a new Dataset page: generate the initial JSON-LD with the Schema MarkupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. Generator, validate it with the Schema Markup Validator, then confirm eligibility (and see exactly which recommended fields you’re still missing) with the Rich-Result Eligibility Checker — before you publish and wait for Google Dataset Search to pick it up.

Proving your Dataset markup actually took effect

Run these after you ship or edit Dataset JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. on a page — each one is a pass/fail check with a clear rollback signal, not a general health check.

Before you test, get the publishing setup right. Google recommends placing Dataset markup on the canonical dataset landing page — not on every page that merely mentions the dataset. If the same dataset is described on more than one page (a mirror, a partner site, a repository record), use sameAs to point at the canonical version instead of duplicating full markup everywhere. And add the dataset’s landing page to your sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. — Google names this as something that helps discovery, not something that guarantees it. None of this is required for markup to validate, but skipping it is a common reason otherwise-clean Dataset markup underperforms.

Test 1: JSON-LD structural validity

Test to run: paste the page’s Dataset JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. into the Schema Markup Validator. Expected result: no errors on the Dataset block — name and description present, description length inside the 50–5,000 character window, and any license/distribution URLs well-formed. Failure interpretation: an error here almost always traces to one of the three concrete mistakes this article covers — a description outside the character window, a license string that isn’t a real URL, or a stray csvw:Table value from a CSV-on-the-Web export. Monitoring window: immediate — this is a syntax check, not a crawl-dependent signal. Rollback trigger: any error-severity finding; ship the corrected JSON-LD the validator hands back before moving to the next test.

Test 2: Dataset rich-result eligibility

Test to run: run the same URL or JSON-LD through the Rich-Result Eligibility Checker and open the Dataset feature card. Expected result: a ✓ eligible verdict on the two required properties, with the recommended-field list showing which of creator, license, distribution.contentUrl, identifier, sameAs, temporalCoverage, spatialCoverage, variableMeasured, keywords, and url you’ve covered. Failure interpretation: a ✗ means one of the two required properties (name or description) is missing or empty on the parsed node — check for a typo in the property name or a value nested where the checker can’t resolve it. Monitoring window: immediate, same as Test 1 — this doesn’t depend on Google having crawled the page yet. Rollback trigger: a ✗ on either required property; don’t consider the markup shippable until this clears.

Test 3: Appearance in Google Dataset Search

Test to run: search for your dataset’s exact name (or site: your domain) in Google Dataset Search once the page has had time to be recrawled and reindexed. Expected result: your dataset listing appears, showing the name, description, and license you set — confirming the markup was not just valid but actually picked up. Failure interpretation: if the page doesn’t appear after a reasonable wait, check Search Console for crawl/indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. issues on the URL first — Dataset Search draws from Google’s regular index, so an uncrawled or noindexed page won’t show up regardless of how clean the JSON-LD is. Monitoring window: Google’s general troubleshooting guidance is to allow several days for recrawling and reindexing before concluding something’s wrong — but that’s troubleshooting guidance, not a committed Dataset Search inclusion timeline, and Google doesn’t guarantee inclusion at all. Rollback trigger: there’s no fixed deadline that proves failure. If Search Console shows the page cleanly indexed and enough time has passed that you’d reasonably expect a check-in, re-verify the canonical-landing-page and sameAs setup above, then re-check for the duplicate/generic-name problem Google specifically flags — a non-unique name is a plausible reason a technically valid dataset still doesn’t stand out in Dataset Search. Treat non-appearance as a prompt to re-audit your setup, not proof the markup failed.

Test yourself: Dataset Schema

Five quick questions on schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./Dataset, the Dataset Search distinction, and the properties that matter. Pick an answer for each, then check.

Resources worth your time

My writing on this topic

I haven’t published a standalone Dataset schemaDataset schema (schema.org/Dataset) is structured data that marks up a data collection so it can surface in Google's dedicated Dataset Search tool — a separate destination from the main web-search results, not a mainstream rich snippet. guide of my own — so rather than point you at something that doesn’t exist, the honest move is to send you to the primary sources below and to the related structured-data work on this site. For the broader vocabulary and where Dataset fits among the Creative Works types, see the Schema MarkupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. and Structured DataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. hubs; for the machine-readability angle, Schema Markup for AISchema markup (structured data) is machine-readable code — usually JSON-LD — that labels what your content means using the schema.org vocabulary. For AI search it's infrastructure for entity disambiguation, not a direct citation lever: controlled studies found no meaningful uplift in AI citations from adding it..

From around the industry

• Dataset structured data (Google Search Central) — the authoritative reference: required name/description, the recommended-property list, and the common-mistakes guidance.
• Google Dataset Search (Google) — the actual destination this markup feeds; browse it to understand what a good result looks like.
• Structured data search gallery (Google) — the full feature catalog, useful for seeing that Dataset sits apart from on-SERP rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show..
• What Is Schema Markup? How to Add It & Why It Matters (Ahrefs) — a solid general schema guide.

Dataset Schema

Dataset schema (schema.org/Dataset) is structured data that marks up a data collection so it can surface in Google's dedicated Dataset Search tool — a separate destination from the main web-search results, not a mainstream rich snippet.

Related: Schema Markup, Structured Data, Article Schema, Book Schema

Dataset Schema

Dataset schema is the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./Dataset structured-data vocabulary you add to a page that publishes a data collection — usually as JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. — describing the dataset’s name, description, creator, license, distribution formats, and coverage. Unlike most schema types, its payoff is not a mainstream Google web-search rich snippet. Instead it feeds Google’s Dataset Search tool at datasetsearch.research.google.com, a distinct destination Google built for researchers and data scientists — a November 5, 2025 Google Search Central documentation update explicitly clarified it’s used only by Dataset Search, not mainstream Google Search.

The only properties Google’s current Dataset Search profile requires are description (50–5000 characters, of which Dataset Search reads only the first 5000) and name. Recommended properties that matter more here than in most CreativeWork types include license and isAccessibleForFree — Dataset Search users are often weighing reuse, though license, access rights, and legal rights are distinct layers (per DCAT) and the markup itself doesn’t decide legal reuse rights — along with creator, identifier, keywords, spatialCoverage, temporalCoverage, variableMeasured, and distribution. Google explicitly flags duplicate generic names (many “Snow depth” datasets from different providers, undisambiguated) as a real-world problem.

This is a niche play for research institutions, .gov/.edu open-data portals, ML dataset hosting, and journals with supplementary data — not a general SEO ranking or rich-result tactic. If your site has no literal dataset to publish, this markup is not for you.

Related: Schema Markup, Structured Data, Article Schema, Book Schema

Changelog