diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 0d3fb92f6..8e21e786d 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -2,6 +2,8 @@
 
 ## 8.1.0-beta
 
+- Add schema.org microdata support to `HtmlProvider`: when an HTML document contains elements with `itemscope`/`itemtype`/`itemprop` attributes, the provider now generates a typed `Schemas` container (e.g. `doc.Schemas.Person`) with one strongly-typed property per `itemprop` name discovered in the sample (closes #611)
+- Add JSON-LD support to `HtmlProvider`: when an HTML document contains `<script type="application/ld+json">` blocks, the provider generates a typed `JsonLd` container (e.g. `doc.JsonLd.Article`) with one strongly-typed property per top-level scalar field discovered in the sample — Wikipedia pages, for instance, embed schema.org `Article` JSON-LD with `name`, `headline`, `description`, `url`, `datePublished`, and `dateModified`
 - Add `ExceptionIfMissing` static parameter to `JsonProvider` and `XmlProvider`: when true, accessing a non-optional field that is missing in the data raises an exception instead of silently returning a default value (empty string for string, NaN for float). Defaults to false for backward compatibility.
 - Add `Http.ParseLinkHeader` utility for parsing RFC 5988 `Link` response headers (used by GitHub, GitLab, and other paginated APIs) into a `Map<string, string>` from relation name to URL (closes #805)
 - Add `PreferDateTimeOffset` parameter to `CsvProvider`, `JsonProvider`, and `XmlProvider`: when true, date-time values without an explicit timezone offset are inferred as `DateTimeOffset` (using local offset) instead of `DateTime` (closes #1100, #1072)
diff --git a/docs/library/HtmlProvider.fsx b/docs/library/HtmlProvider.fsx
index 4daae4049..0b39db6e9 100644
--- a/docs/library/HtmlProvider.fsx
+++ b/docs/library/HtmlProvider.fsx
@@ -28,28 +28,41 @@ Formatter.Register(fun (x: obj) (writer: TextWriter) -> fprintfn writer "%120A"
 
 # HTML Type Provider
 
-This article demonstrates how to use the HTML type provider to read HTML tables files
-in a statically typed way.
+This article demonstrates how to use the HTML type provider to read HTML pages in a
+statically typed way. The provider is useful for extracting data from pages that expose
+information as HTML tables or via [schema.org microdata](https://schema.org/) markup.
 
-The HTML Type Provider takes a sample HTML document as input and generates a type based on the data
-present in the columns of that sample. The column names are obtained from the first (header) row.
+The HTML Type Provider takes a sample HTML document as input — either a URL, a local file
+path, or an inline HTML string — and generates F# types for the tables and microdata found
+in that document. You can then load live data using the same or a different URL at runtime.
 
-## Introducing the provider
+## Parsing HTML Tables
+
+HTML tables (`<table>` elements) are the primary target of the HTML Type Provider.
+Each discovered table becomes a typed property on the generated `.Tables` container.
+
+**Table naming**: Table properties are named after the nearest preceding heading element
+(`<h2>`, `<h3>`, etc.), the `<caption>` element, or the table's `id`, `name`, `title`,
+`summary`, or `aria-label` attribute — whichever is found first. If none are found the
+table is named `Table1`, `Table2`, etc. by position.
+
+**Column types**: The provider infers column types (`int`, `float`, `DateTime`, `string`,
+etc.) from the values in the sample document. Columns that cannot be fully inferred
+default to `string`.
 
-The type provider is located in the `FSharp.Data.dll` assembly. Assuming the assembly
-is located in the `../../../bin` directory, we can load it in F# Interactive as follows:
 *)
 
 open FSharp.Data
 
 (**
 
-### Parsing F1 Calendar Data
+### Formula 1 Race Calendar (Wikipedia)
 
-This example shows an example of using the HTML Type Provider to extract each row from a table on a Wikipedia page.
+This example extracts the 2017 Formula 1 race calendar from Wikipedia. The page has
+multiple tables; we access the one whose nearest preceding heading is "Calendar".
 
-Usually with HTML files headers are demarked by using the `<th>` tag, however this is not true in general, so the provider assumes that the
-first row is headers. (This behaviour is likely to get smarter in later releases). But it highlights a general problem about HTML's strictness.
+The provider infers that `Round` is an integer and `Date` is a `DateTime` based on the
+sample data.
 *)
 
 [<Literal>]
@@ -58,13 +71,6 @@ let F1_2017_URL =
 
 type F1_2017 = HtmlProvider<F1_2017_URL>
 
-(**
-The generated type provides a type space of tables that it has managed to parse out of the given HTML Document.
-Each type's name is derived from either the id, title, name, summary or caption attributes/tags provided. If none of these
-entities exist then the table will simply be named `Tablexx` where xx is the position in the HTML document if all of the tables were flattened out into a list.
-The `Load` method allows reading the data from a file or web resource. We could also have used a web URL instead of a local file in the sample parameter of the type provider.
-The following sample calls the `Load` method with an URL that points to a live version of the same page on Wikipedia.
-*)
 // Download the table for the 2017 F1 calendar from Wikipedia
 let f1Calendar = F1_2017.Load(F1_2017_URL).Tables.Calendar
 
@@ -74,45 +80,79 @@ let round = firstRow.Round
 let grandPrix = firstRow.``Grand Prix``
 let date = firstRow.Date
 
-// Print the round, location and date for each race, corresponding to a row
+// Print the round, location and date for each race
 for row in f1Calendar.Rows do
     printfn "Race, round %A is hosted at %A on %A" row.Round row.``Grand Prix`` row.Date
 
 (*** include-fsi-merged-output ***)
 
 (**
-The generated type has a property `Rows` that returns the data from the HTML file as a
-collection of rows. We iterate over the rows using a `for` loop. As you can see the
-(generated) type for rows has properties such as `Grand Prix`, `Circuit`, `Round` and `Date` that correspond
-to the columns in the selected HTML table file.
-
-As you can see, the type provider also infers types of individual rows. The `Date`
-property is inferred to be a `DateTime` (because the values in the sample file can all
-be parsed as dates) while other columns are inferred as the correct type where possible.
+The generated type has a property `Rows` that returns the data from the HTML page as a
+collection of rows. We iterate over the rows using a `for` loop. The row type has
+properties such as `Grand Prix`, `Circuit`, `Round` and `Date` that correspond to the
+columns in the HTML table.
+
+The `Load` method accepts any URL, file path, or HTML string — we could load a different
+season's page at runtime while still using the 2017 page for type inference at compile time.
+
+### Wikipedia S&P 500 Components
+
+This example queries the Wikipedia list of S&P 500 companies, which exposes symbol,
+sector, and founding year for each constituent. Note that the table has no heading or
+caption, so the provider names it `Table1` by position.
 *)
 
-(**
+[<Literal>]
+let SP500_URL =
+    "https://en.wikipedia.org/wiki/List_of_S%26P_500_companies"
+
+type SP500 = HtmlProvider<SP500_URL>
 
-### Parsing Nuget package stats
+let sp500 = SP500.Load(SP500_URL)
 
-This small sample shows how the HTML Type Provider can be used to scrape data from a website. In this example, we analyze the download counts of the FSharp.Data package on NuGet.
-Note that we're using the live URL as the sample, so we can just use the default constructor as the runtime data will be the same as the compile time data.
+// Table1 is the main constituents table (no caption on the Wikipedia page)
+let companies = sp500.Tables.Table1
 
+// Show the first five companies with their sector
+for row in companies.Rows |> Seq.truncate 5 do
+    printfn "%s (%s) — %s, founded %d" row.Symbol row.Security row.``GICS Sector`` row.Founded
+
+(*** include-fsi-merged-output ***)
+
+(**
+We can also use standard F# collection functions to analyse the data — for example,
+grouping companies by sector to see how many are in each:
 *)
 
+let bySector =
+    companies.Rows
+    |> Seq.groupBy (fun r -> r.``GICS Sector``)
+    |> Seq.map (fun (sector, rows) -> sector, Seq.length rows)
+    |> Seq.sortByDescending snd
+    |> Seq.toArray
+
+(*** include-fsi-merged-output ***)
+
+(**
+
+### NuGet Package Statistics
+
+This example uses the HTML Type Provider to scrape download statistics for the
+`FSharp.Data` package from NuGet. Because we pass the live URL as the type parameter,
+the default constructor loads the same live page at runtime.
+*)
 
-// Configure the type provider
 type NugetStats = HtmlProvider<"https://www.nuget.org/packages/FSharp.Data">
 
-// load the live package stats for FSharp.Data
+// Load the live package stats for FSharp.Data
 let rawStats = NugetStats().Tables.``Version History of FSharp.Data``
 
-// helper function to analyze version numbers from Nuget
+// Helper to extract the minor version string (e.g. "6.4" from "6.4.0")
 let getMinorVersion (v: string) =
-    System.Text.RegularExpressions.Regex(@"\d.\d").Match(v).Value
+    System.Text.RegularExpressions.Regex(@"\d+\.\d+").Match(v).Value
 
-// group by minor version and calculate the download count
-let stats =
+// Group downloads by minor version
+let downloadsByMinorVersion =
     rawStats.Rows
     |> Seq.groupBy (fun r -> getMinorVersion r.Version)
     |> Seq.map (fun (k, xs) -> k, xs |> Seq.sumBy (fun x -> x.Downloads))
@@ -122,34 +162,319 @@ let stats =
 
 (**
 
-### Getting statistics on Doctor Who
-
-This sample shows some more screen scraping from Wikipedia:
+### Getting Statistics on Doctor Who (Multiple Tables)
 
+Wikipedia pages often contain many tables. This example loads the Doctor Who episode
+guide and aggregates viewing figures by director across the first series.
 *)
 
-(*** define-output:doctorWhoChart ***)
 [<Literal>]
 let DrWho =
     "https://en.wikipedia.org/wiki/List_of_Doctor_Who_episodes_(1963%E2%80%931989)"
 
 let doctorWho = new HtmlProvider<DrWho>()
 
-// Get the average number of viewers for each doctor's series run
-let viewersByDoctor =
+// Get the average number of viewers for each director in Series 1
+let viewersByDirector =
     doctorWho.Tables.``Season 1 (1963-1964)``.Rows
-    |> Seq.groupBy (fun season -> season.``Directed by``)
-    |> Seq.map (fun (doctor, seasons) ->
-        let averaged =
-            seasons |> Seq.averageBy (fun season -> season.``UK viewers (millions)``)
+    |> Seq.groupBy (fun episode -> episode.``Directed by``)
+    |> Seq.map (fun (director, episodes) ->
+        let avgViewers =
+            episodes |> Seq.averageBy (fun e -> e.``UK viewers (millions)``)
 
-        doctor, averaged)
+        director, avgViewers)
     |> Seq.toArray
 
+(*** include-fsi-merged-output ***)
+
+(**
+
+## Schema.org Microdata
+
+In addition to HTML tables, the provider also understands
+[HTML microdata](https://html.spec.whatwg.org/multipage/microdata.html) — the
+`itemscope` / `itemtype` / `itemprop` attributes defined by the
+[schema.org](https://schema.org/) vocabulary.  When the sample document contains
+`itemscope` elements, the provider generates a `.Schemas` container with one typed
+property per schema type found.
+
+The example below uses an inline HTML string as the type parameter sample.  At runtime
+you can call `.Load(url)` to parse any live page that uses the same schema types.
+*)
+
+[<Literal>]
+let ProductCatalogSample =
+    """<html><body>
+  <div itemscope itemtype="http://schema.org/Product">
+    <span itemprop="name">FSharp.Data</span>
+    <span itemprop="description">F# data-access library</span>
+    <span itemprop="brand">F# Foundation</span>
+    <span itemprop="sku">FSHARP-DATA</span>
+  </div>
+  <div itemscope itemtype="http://schema.org/Product">
+    <span itemprop="name">Newtonsoft.Json</span>
+    <span itemprop="description">Popular high-performance JSON framework for .NET</span>
+    <span itemprop="brand">James Newton-King</span>
+    <span itemprop="sku">NEWTONSOFT-JSON</span>
+  </div>
+</body></html>"""
+
+type ProductCatalog = HtmlProvider<ProductCatalogSample>
+
+let catalog = ProductCatalog.Parse(ProductCatalogSample)
+
+// Schemas.Product returns an array of typed Product items
+for product in catalog.Schemas.Product do
+    printfn "%s — %s (SKU: %s)" product.Name product.Brand product.Sku
 
 (*** include-fsi-merged-output ***)
 
 (**
+Each item in `Schemas.Product` has one string property per `itemprop` name discovered in
+the sample, with names Pascal-cased for F# convention.  The `.Html` property gives
+access to the underlying `HtmlNode` for cases where you need to traverse sub-elements.
+
+You can mix microdata and table extraction in the same type:
+*)
+
+[<Literal>]
+let MixedPageSample =
+    """<html><body>
+  <div itemscope itemtype="http://schema.org/Person">
+    <span itemprop="name">Grace Hopper</span>
+    <span itemprop="jobTitle">Rear Admiral</span>
+    <span itemprop="alumniOf">Yale University</span>
+  </div>
+  <table>
+    <tr><th>Year</th><th>Achievement</th></tr>
+    <tr><td>1944</td><td>Debugged the Harvard Mark II</td></tr>
+    <tr><td>1952</td><td>First compiler (A-0 System)</td></tr>
+    <tr><td>1959</td><td>Co-designed COBOL</td></tr>
+  </table>
+</body></html>"""
+
+type PersonPage = HtmlProvider<MixedPageSample>
+
+let page = PersonPage.Parse(MixedPageSample)
+
+// Access the microdata
+let person = page.Schemas.Person |> Array.head
+printfn "Name: %s, Title: %s" person.Name person.JobTitle
+
+// Access the table
+for row in page.Tables.Table1.Rows do
+    printfn "%d: %s" row.Year row.Achievement
+
+(*** include-fsi-merged-output ***)
+
+(**
+
+## JSON-LD Structured Data
+
+Many modern websites — including **Wikipedia** — embed structured metadata as
+[JSON-LD](https://json-ld.org/) inside `<script type="application/ld+json">` elements in
+the page `<head>`.  `HtmlProvider` now parses these blocks automatically and exposes them
+via a typed `.JsonLd` container, exactly like the `.Schemas` container for microdata.
+
+### What Wikipedia exposes via JSON-LD
+
+Wikipedia embeds a JSON-LD block on every article page that describes the article using
+the [schema.org `Article` type](https://schema.org/Article).  The block includes:
+
+| Property | Description |
+|---|---|
+| `name` | Article title |
+| `headline` | Short headline |
+| `description` | Brief description |
+| `url` | Canonical URL |
+| `datePublished` | First published date |
+| `dateModified` | Last modified date |
+
+Wikipedia also has pages about specific entities (people, places, organisations, events)
+that carry a `mainEntity` link back to the corresponding [Wikidata](https://www.wikidata.org/)
+item, and article categories encoded as `about` objects.
+
+The sample HTML below mirrors the structure Wikipedia actually serves:
+*)
+
+[<Literal>]
+let WikipediaArticleSample =
+    """<html>
+<head>
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    "name": "F Sharp (programming language)",
+    "headline": "Functional-first programming language for .NET",
+    "description": "F# is a strongly typed, multi-paradigm programming language.",
+    "url": "https://en.wikipedia.org/wiki/F_Sharp_(programming_language)",
+    "datePublished": "2003-01-01",
+    "dateModified": "2024-06-15",
+    "license": "https://creativecommons.org/licenses/by-sa/4.0/",
+    "inLanguage": "en"
+  }
+  </script>
+</head>
+<body>
+  <table>
+    <tr><th>Year</th><th>Event</th></tr>
+    <tr><td>2002</td><td>F# created by Don Syme at Microsoft Research Cambridge</td></tr>
+    <tr><td>2005</td><td>First public release of F#</td></tr>
+    <tr><td>2010</td><td>F# ships with Visual Studio 2010</td></tr>
+    <tr><td>2020</td><td>F# 5.0 released</td></tr>
+  </table>
+</body>
+</html>"""
+
+type WikipediaArticle = HtmlProvider<WikipediaArticleSample>
+
+let wiki = WikipediaArticle.Parse(WikipediaArticleSample)
+
+// Access the JSON-LD Article metadata
+let article = wiki.JsonLd.Article |> Array.head
+printfn "Title: %s" article.Name
+printfn "Description: %s" article.Description
+printfn "Published: %s  |  Modified: %s" article.DatePublished article.DateModified
+printfn "URL: %s" article.Url
+
+(*** include-fsi-merged-output ***)
+
+(**
+The `.JsonLd` container has one property per `@type` found in the JSON-LD blocks.  Each
+property returns an array of items — so `wiki.JsonLd.Article` is an
+`WikipediaArticle+Article[]`.  Each item has one `string` property per top-level scalar
+field (strings, numbers, booleans), with names Pascal-cased for F# convention.  A `.Raw`
+property gives the original JSON text if you need to access complex nested values.
+
+### Wikipedia timeline article: tables + JSON-LD metadata
+
+The next example shows combining the Wikipedia HTML table (a timeline of events) with the
+JSON-LD article metadata, all via a single provider type:
+*)
+
+// Access the events table in the same page
+for row in wiki.Tables.Table1.Rows do
+    printfn "%d: %s" row.Year row.Event
+
+(*** include-fsi-merged-output ***)
+
+(**
+
+### Multiple JSON-LD types on one page
+
+Some pages include multiple JSON-LD blocks, e.g. a `WebPage` descriptor alongside the
+`Article`.  The provider generates separate typed properties for each `@type`:
+*)
+
+[<Literal>]
+let WikipediaWithWebPageSample =
+    """<html>
+<head>
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "WebPage",
+    "name": "F Sharp — Wikipedia",
+    "url": "https://en.wikipedia.org/wiki/F_Sharp_(programming_language)",
+    "inLanguage": "en",
+    "isPartOf": "https://en.wikipedia.org/"
+  }
+  </script>
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    "name": "F Sharp (programming language)",
+    "headline": "Functional-first programming language for .NET",
+    "description": "F# is a strongly typed, multi-paradigm programming language.",
+    "url": "https://en.wikipedia.org/wiki/F_Sharp_(programming_language)",
+    "datePublished": "2003-01-01",
+    "dateModified": "2024-06-15"
+  }
+  </script>
+</head>
+<body></body>
+</html>"""
+
+type WikipediaWithWebPage = HtmlProvider<WikipediaWithWebPageSample>
+
+let wikiMulti = WikipediaWithWebPage.Parse(WikipediaWithWebPageSample)
+
+// Both JsonLd types are available as separate typed properties
+printfn "WebPage name: %s" wikiMulti.JsonLd.WebPage.[0].Name
+printfn "Article name: %s" wikiMulti.JsonLd.Article.[0].Name
+printfn "Article published: %s" wikiMulti.JsonLd.Article.[0].DatePublished
+
+(*** include-fsi-merged-output ***)
+
+(**
+
+### Accessing raw JSON for complex properties
+
+For properties with nested object values (such as `image`, `author`, or `publisher`
+in a Wikipedia article), only scalar top-level fields are reflected as typed properties.
+Use the `.Raw` property to access the full original JSON and parse it further with
+`JsonProvider` or `JsonValue.Parse` if needed:
+*)
+
+[<Literal>]
+let WikipediaPersonSample =
+    """<html>
+<head>
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    "name": "Alan Turing",
+    "headline": "British mathematician and computer scientist",
+    "description": "Alan Mathison Turing was an English mathematician, computer scientist, logician, cryptanalyst, philosopher, and theoretical biologist.",
+    "url": "https://en.wikipedia.org/wiki/Alan_Turing",
+    "datePublished": "2001-10-13",
+    "dateModified": "2024-09-10",
+    "license": "https://creativecommons.org/licenses/by-sa/4.0/",
+    "inLanguage": "en"
+  }
+  </script>
+</head>
+<body>
+  <table>
+    <tr><th>Year</th><th>Achievement</th></tr>
+    <tr><td>1936</td><td>Turing machine concept published</td></tr>
+    <tr><td>1939</td><td>Bombe code-breaking machine</td></tr>
+    <tr><td>1950</td><td>Turing Test proposed</td></tr>
+  </table>
+</body>
+</html>"""
+
+type WikipediaPerson = HtmlProvider<WikipediaPersonSample>
+
+let turingPage = WikipediaPerson.Parse(WikipediaPersonSample)
+
+// JSON-LD article metadata
+let turingArticle = turingPage.JsonLd.Article.[0]
+printfn "Subject: %s" turingArticle.Name
+printfn "Published: %s" turingArticle.DatePublished
+printfn "License: %s" turingArticle.License
+
+// Timeline table from the article body
+for row in turingPage.Tables.Table1.Rows do
+    printfn "%d — %s" row.Year row.Achievement
+
+(*** include-fsi-merged-output ***)
+
+(**
+
+## Summary of structured data formats
+
+| Format | HTML mechanism | Provider access | Typical use |
+|---|---|---|---|
+| Tables | `<table>` elements | `.Tables.TableName` | Tabular data, statistics |
+| Microdata | `itemscope`/`itemprop` attributes | `.Schemas.TypeName` | Inline product/event/person markup |
+| JSON-LD | `<script type="application/ld+json">` | `.JsonLd.TypeName` | Article/page metadata, SEO |
+
+All three formats can coexist in the same `HtmlProvider` type.
+
 ## Related articles
 
  * [HTML Parser](HtmlParser.html) - provides more information about
diff --git a/src/FSharp.Data.DesignTime/Html/HtmlGenerator.fs b/src/FSharp.Data.DesignTime/Html/HtmlGenerator.fs
index 2d84cf4dc..ffad9a1bb 100644
--- a/src/FSharp.Data.DesignTime/Html/HtmlGenerator.fs
+++ b/src/FSharp.Data.DesignTime/Html/HtmlGenerator.fs
@@ -305,6 +305,94 @@ module internal HtmlGenerator =
 
         definitionListType
 
+    let private createSchemaItemType getSchemaTypeName (schemaGroup: HtmlSchemaGroup) =
+
+        // Each item is erased as HtmlSchemaItem, which carries the property map.
+        let itemType =
+            ProvidedTypeDefinition(
+                getSchemaTypeName schemaGroup.Name,
+                Some typeof<HtmlSchemaItem>,
+                hideObjectMethods = true,
+                nonNullable = true
+            )
+
+        itemType.AddXmlDoc(sprintf "Represents a single schema.org/%s microdata item." schemaGroup.Name)
+
+        for propName in schemaGroup.Properties do
+            let keyCapture = propName
+
+            let prop =
+                ProvidedProperty(
+                    NameUtils.nicePascalName propName,
+                    typeof<string>,
+                    getterCode =
+                        (fun (Singleton item) ->
+                            <@@
+                                (%%item: HtmlSchemaItem).Properties
+                                |> Map.tryFind keyCapture
+                                |> Option.defaultValue ""
+                            @@>)
+                )
+
+            prop.AddXmlDoc(sprintf "Gets the '%s' itemprop value." propName)
+            itemType.AddMember prop
+
+        itemType.AddMember(
+            ProvidedProperty(
+                "Html",
+                typeof<HtmlNode>,
+                getterCode = fun (Singleton item) -> <@@ (%%item: HtmlSchemaItem).Html @@>
+            )
+        )
+
+        itemType
+
+    let private createJsonLdItemType getJsonLdTypeName (group: HtmlJsonLdGroup) =
+
+        // Each item is erased as HtmlJsonLdItem, which carries the property map.
+        let itemType =
+            ProvidedTypeDefinition(
+                getJsonLdTypeName group.Name,
+                Some typeof<HtmlJsonLdItem>,
+                hideObjectMethods = true,
+                nonNullable = true
+            )
+
+        itemType.AddXmlDoc(
+            sprintf
+                "Represents a single JSON-LD item of type '%s' found in a <script type=\"application/ld+json\"> block."
+                group.TypeName
+        )
+
+        for propName in group.Properties do
+            let keyCapture = propName
+
+            let prop =
+                ProvidedProperty(
+                    NameUtils.nicePascalName propName,
+                    typeof<string>,
+                    getterCode =
+                        (fun (Singleton item) ->
+                            <@@
+                                (%%item: HtmlJsonLdItem).Properties
+                                |> Map.tryFind keyCapture
+                                |> Option.defaultValue ""
+                            @@>)
+                )
+
+            prop.AddXmlDoc(sprintf "Gets the '%s' JSON-LD property value." propName)
+            itemType.AddMember prop
+
+        itemType.AddMember(
+            ProvidedProperty(
+                "Raw",
+                typeof<string>,
+                getterCode = fun (Singleton item) -> <@@ (%%item: HtmlJsonLdItem).Raw @@>
+            )
+        )
+
+        itemType
+
     let generateTypes asm ns typeName parameters supportsNet6Types htmlObjects =
 
         let htmlType =
@@ -383,4 +471,34 @@ module internal HtmlGenerator =
                     getterCode = fun (Singleton doc) -> doc
                 )
 
+            | SchemaGroup schemaGroup ->
+                let containerType = getOrCreateContainer "Schemas"
+                let nameCapture = schemaGroup.Name
+                let itemType = createSchemaItemType getTypeName schemaGroup
+
+                htmlType.AddMember itemType
+
+                // Expose as a property returning an array of item types (erased as HtmlSchemaItem[])
+                containerType.AddMember
+                <| ProvidedProperty(
+                    getPropertyName schemaGroup.Name,
+                    itemType.MakeArrayType(),
+                    getterCode = fun (Singleton doc) -> <@@ (%%doc: HtmlDocument).GetSchema(nameCapture).Items @@>
+                )
+
+            | JsonLdGroup group ->
+                let containerType = getOrCreateContainer "JsonLd"
+                let nameCapture = group.Name
+                let itemType = createJsonLdItemType getTypeName group
+
+                htmlType.AddMember itemType
+
+                // Expose as a property returning an array of item types (erased as HtmlJsonLdItem[])
+                containerType.AddMember
+                <| ProvidedProperty(
+                    getPropertyName group.Name,
+                    itemType.MakeArrayType(),
+                    getterCode = fun (Singleton doc) -> <@@ (%%doc: HtmlDocument).GetJsonLd(nameCapture).Items @@>
+                )
+
         htmlType
diff --git a/src/FSharp.Data.Html.Core/FSharp.Data.Html.Core.fsproj b/src/FSharp.Data.Html.Core/FSharp.Data.Html.Core.fsproj
index 9b372d0d9..5820befb6 100644
--- a/src/FSharp.Data.Html.Core/FSharp.Data.Html.Core.fsproj
+++ b/src/FSharp.Data.Html.Core/FSharp.Data.Html.Core.fsproj
@@ -30,6 +30,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="../FSharp.Data.Csv.Core/FSharp.Data.Csv.Core.fsproj" />
+    <ProjectReference Include="../FSharp.Data.Json.Core/FSharp.Data.Json.Core.fsproj" />
     <ProjectReference Include="../FSharp.Data.Runtime.Utilities/FSharp.Data.Runtime.Utilities.fsproj" />
   </ItemGroup>
   <Import Project="..\..\.paket\Paket.Restore.targets" />
diff --git a/src/FSharp.Data.Html.Core/HtmlRuntime.fs b/src/FSharp.Data.Html.Core/HtmlRuntime.fs
index 751cd46d8..f6d451a51 100644
--- a/src/FSharp.Data.Html.Core/HtmlRuntime.fs
+++ b/src/FSharp.Data.Html.Core/HtmlRuntime.fs
@@ -109,17 +109,81 @@ type HtmlDefinitionList =
 
         sb.ToString()
 
+/// Representation of a single schema.org microdata item (an element with itemscope/itemtype)
+type HtmlSchemaItem =
+    { Properties: Map<string, string>
+      Html: HtmlNode }
+
+/// Representation of a collection of schema.org microdata items sharing the same type URL
+type HtmlSchemaGroup =
+    {
+        /// The local name from the schema type URL (e.g. "Person" from "http://schema.org/Person")
+        Name: string
+        /// The full schema type URL (e.g. "http://schema.org/Person")
+        TypeUrl: string
+        /// All item instances found in the document for this schema type
+        Items: HtmlSchemaItem[]
+        /// All property names discovered across items (union of keys), for type generation
+        Properties: string[]
+    }
+
+    override x.ToString() =
+        let sb = System.Text.StringBuilder()
+        sb.AppendLine(sprintf "%s (%d items)" x.Name x.Items.Length) |> ignore
+
+        for item in x.Items do
+            for (k, v) in item.Properties |> Map.toSeq do
+                sb.AppendLine(sprintf "  %s = %s" k v) |> ignore
+
+        sb.ToString()
+
+/// A single JSON-LD item parsed from a <script type="application/ld+json"> element
+type HtmlJsonLdItem =
+    {
+        /// Flat string representation of top-level scalar properties (strings, numbers, booleans)
+        Properties: Map<string, string>
+        /// The raw JSON text of this item
+        Raw: string
+    }
+
+/// A group of JSON-LD items sharing the same @type value
+type HtmlJsonLdGroup =
+    {
+        /// The local type name (e.g. "Article" from "@type": "https://schema.org/Article")
+        Name: string
+        /// The raw @type value
+        TypeName: string
+        /// All items in this group
+        Items: HtmlJsonLdItem[]
+        /// Union of all property names discovered across items, for type generation
+        Properties: string[]
+    }
+
+    override x.ToString() =
+        let sb = System.Text.StringBuilder()
+        sb.AppendLine(sprintf "%s (%d items)" x.Name x.Items.Length) |> ignore
+
+        for item in x.Items do
+            for (k, v) in item.Properties |> Map.toSeq do
+                sb.AppendLine(sprintf "  %s = %s" k v) |> ignore
+
+        sb.ToString()
+
 /// Representation of an HTML table, list, or definition list
 type HtmlObjectDescription =
     | Table of HtmlTable
     | List of HtmlList
     | DefinitionList of HtmlDefinitionList
+    | SchemaGroup of HtmlSchemaGroup
+    | JsonLdGroup of HtmlJsonLdGroup
 
     member x.Name =
         match x with
         | Table t -> t.Name
         | List l -> l.Name
         | DefinitionList dl -> dl.Name
+        | SchemaGroup sg -> sg.Name
+        | JsonLdGroup jl -> jl.Name
 
 // --------------------------------------------------------------------------------------
 
@@ -396,6 +460,217 @@ module HtmlRuntime =
               Html = definitionList }
             |> Some
 
+
+    let private hasAttr (name: string) (n: HtmlNode) = n.TryGetAttribute name |> Option.isSome
+
+    /// Extract the property value for a schema.org microdata itemprop element.
+    /// Follows the HTML microdata specification: uses content attr, href, src, or inner text.
+    let private getMicrodataValue (node: HtmlNode) =
+        match node with
+        | HtmlElement("meta", _, _) ->
+            node.TryGetAttribute "content"
+            |> Option.map HtmlAttribute.value
+            |> Option.defaultValue ""
+        | HtmlElement("a", _, _)
+        | HtmlElement("link", _, _) ->
+            node.TryGetAttribute "href"
+            |> Option.map HtmlAttribute.value
+            |> Option.defaultWith (fun () -> node.InnerText())
+        | HtmlElement("img", _, _)
+        | HtmlElement("audio", _, _)
+        | HtmlElement("video", _, _)
+        | HtmlElement("source", _, _) ->
+            node.TryGetAttribute "src"
+            |> Option.map HtmlAttribute.value
+            |> Option.defaultValue ""
+        | HtmlElement("time", _, _) ->
+            node.TryGetAttribute "datetime"
+            |> Option.map HtmlAttribute.value
+            |> Option.defaultWith (fun () -> normalizeWs (node.InnerText()))
+        | _ ->
+            node.TryGetAttribute "content"
+            |> Option.map HtmlAttribute.value
+            |> Option.defaultWith (fun () -> normalizeWs (node.InnerText()))
+
+    /// Parse a single itemscope element into an HtmlSchemaItem.
+    /// Extracts all direct (non-nested) itemprop values.
+    let private parseSchemaItem (node: HtmlNode) : HtmlSchemaItem =
+        let rec collectProps acc (n: HtmlNode) : (string * string) list =
+            match n with
+            | HtmlElement(_, _, children) ->
+                let hasProp = n.TryGetAttribute "itemprop" |> Option.map HtmlAttribute.value
+
+                let isNestedScope = hasAttr "itemscope" n && n <> node
+
+                match hasProp with
+                | Some propName ->
+                    let value = getMicrodataValue n
+                    let acc' = (propName, value) :: acc
+                    // Don't recurse into nested itemscope elements
+                    if isNestedScope then
+                        acc'
+                    else
+                        List.fold collectProps acc' children
+                | None ->
+                    if isNestedScope then
+                        acc
+                    else
+                        List.fold collectProps acc children
+            | _ -> acc
+
+        let children =
+            match node with
+            | HtmlElement(_, _, cs) -> cs
+            | _ -> []
+
+        let props = List.fold collectProps [] children |> List.rev
+
+        let propMap =
+            props
+            |> List.fold (fun (m: Map<string, string>) (k, v) -> if m.ContainsKey k then m else m.Add(k, v)) Map.empty
+
+        { Properties = propMap; Html = node }
+
+    /// Get the local name from a schema type URL, e.g. "Person" from "http://schema.org/Person"
+    let private schemaTypeName (typeUrl: string) =
+        let last = typeUrl.TrimEnd('/').Split([| '/'; '#' |]) |> Array.last
+
+        if String.IsNullOrWhiteSpace last then
+            "Schema"
+        else
+            NameUtils.nicePascalName last
+
+    /// Extract all schema.org microdata groups from the document,
+    /// grouped by itemtype URL.
+    let getSchemas (doc: HtmlDocument) : HtmlSchemaGroup list =
+        let makeUnique = NameUtils.uniqueGenerator id
+
+        doc.Descendants((fun n -> hasAttr "itemscope" n && hasAttr "itemtype" n), false)
+        |> Seq.toList
+        |> List.groupBy (fun n ->
+            n.TryGetAttribute "itemtype"
+            |> Option.map HtmlAttribute.value
+            |> Option.defaultValue "")
+        |> List.filter (fun (typeUrl, _) -> typeUrl <> "")
+        |> List.map (fun (typeUrl, nodes) ->
+            let name = makeUnique (schemaTypeName typeUrl)
+            let items = nodes |> List.map parseSchemaItem |> Array.ofList
+
+            let allProps =
+                items
+                |> Array.collect (fun item -> item.Properties |> Map.toArray |> Array.map fst)
+                |> Array.distinct
+
+            { Name = name
+              TypeUrl = typeUrl
+              Items = items
+              Properties = allProps })
+
+    /// Get the local type name from a JSON-LD @type value,
+    /// e.g. "Article" from "https://schema.org/Article" or "Article"
+    let private jsonLdTypeName (typeName: string) =
+        let last = typeName.TrimEnd('/').Split([| '/'; '#' |]) |> Array.last
+
+        if String.IsNullOrWhiteSpace last then
+            "JsonLd"
+        else
+            NameUtils.nicePascalName last
+
+    /// Extract top-level scalar properties from a JSON-LD object (JsonValue.Record).
+    /// Skips @context, @type, @id and complex nested values.
+    let private extractJsonLdProperties (json: JsonValue) : Map<string, string> =
+        match json with
+        | JsonValue.Record props ->
+            props
+            |> Array.choose (fun (k, v) ->
+                if k.StartsWith("@") then
+                    None
+                else
+                    match v with
+                    | JsonValue.String s -> Some(k, s)
+                    | JsonValue.Number n -> Some(k, string n)
+                    | JsonValue.Boolean b -> Some(k, if b then "true" else "false")
+                    | JsonValue.Array arr when arr.Length > 0 ->
+                        // For arrays, take the first string/number element as representative
+                        arr
+                        |> Array.tryPick (fun elem ->
+                            match elem with
+                            | JsonValue.String s -> Some(k, s)
+                            | JsonValue.Number n -> Some(k, string n)
+                            | _ -> None)
+                    | _ -> None)
+            |> Map.ofArray
+        | _ -> Map.empty
+
+    /// Parse all JSON-LD groups from <script type="application/ld+json"> elements,
+    /// grouped by @type.
+    let getJsonLd (doc: HtmlDocument) : HtmlJsonLdGroup list =
+        let makeUnique = NameUtils.uniqueGenerator id
+
+        doc.Descendants(
+            (fun n ->
+                match n with
+                | HtmlElement("script", attrs, _) ->
+                    attrs
+                    |> List.exists (fun a ->
+                        HtmlAttribute.name a = "type" && HtmlAttribute.value a = "application/ld+json")
+                | _ -> false),
+            false
+        )
+        |> Seq.toList
+        |> List.collect (fun script ->
+            let text = script.InnerText()
+
+            try
+                let json = JsonValue.Parse text
+
+                match json with
+                | JsonValue.Array items -> items |> Array.toList
+                | obj -> [ obj ]
+            with _ ->
+                [])
+        |> List.choose (fun json ->
+            match json with
+            | JsonValue.Record props ->
+                let typeName =
+                    props
+                    |> Array.tryPick (fun (k, v) ->
+                        if k = "@type" then
+                            match v with
+                            | JsonValue.String s -> Some s
+                            | JsonValue.Array arr ->
+                                arr
+                                |> Array.tryPick (fun e ->
+                                    match e with
+                                    | JsonValue.String s -> Some s
+                                    | _ -> None)
+                            | _ -> None
+                        else
+                            None)
+
+                typeName |> Option.map (fun t -> t, json)
+            | _ -> None)
+        |> List.groupBy fst
+        |> List.map (fun (typeName, items) ->
+            let name = makeUnique (jsonLdTypeName typeName)
+
+            let jsonLdItems =
+                items
+                |> List.map (fun (_, json) ->
+                    { Properties = extractJsonLdProperties json
+                      Raw = json.ToString() })
+                |> Array.ofList
+
+            let allProps =
+                jsonLdItems
+                |> Array.collect (fun item -> item.Properties |> Map.toArray |> Array.map fst)
+                |> Array.distinct
+
+            { Name = name
+              TypeName = typeName
+              Items = jsonLdItems
+              Properties = allProps })
+
     let internal getTables inferenceParameters includeLayoutTables (doc: HtmlDocument) =
         let tableElements = doc.DescendantsWithPath "table" |> List.ofSeq
 
@@ -429,7 +704,9 @@ module HtmlRuntime =
         Seq.concat
             [ doc |> getTables inferenceParameters includeLayoutTables |> List.map Table
               doc |> getLists |> List.map List
-              doc |> getDefinitionLists |> List.map DefinitionList ]
+              doc |> getDefinitionLists |> List.map DefinitionList
+              doc |> getSchemas |> List.map SchemaGroup
+              doc |> getJsonLd |> List.map JsonLdGroup ]
 
 // --------------------------------------------------------------------------------------
 
@@ -442,7 +719,7 @@ open FSharp.Data
 open FSharp.Data.Runtime
 
 /// Underlying representation of the root types generated by HtmlProvider
-type HtmlDocument internal (doc, tables, lists, definitionLists) =
+type HtmlDocument internal (doc, tables, lists, definitionLists, schemas, jsonLd) =
 
     member _.Html = doc
 
@@ -470,7 +747,13 @@ type HtmlDocument internal (doc, tables, lists, definitionLists) =
             |> List.map (fun e -> e.Name, e)
             |> Map.ofList
 
-        HtmlDocument(doc, tables, lists, definitionLists)
+        let schemas =
+            doc |> HtmlRuntime.getSchemas |> List.map (fun e -> e.Name, e) |> Map.ofList
+
+        let jsonLd =
+            doc |> HtmlRuntime.getJsonLd |> List.map (fun e -> e.Name, e) |> Map.ofList
+
+        HtmlDocument(doc, tables, lists, definitionLists, schemas, jsonLd)
 
     /// <exclude />
     [<EditorBrowsableAttribute(EditorBrowsableState.Never)>]
@@ -496,6 +779,22 @@ type HtmlDocument internal (doc, tables, lists, definitionLists) =
                                IsError = false)>]
     member _.GetDefinitionList(id: string) = definitionLists |> Map.find id
 
+    /// <exclude />
+    [<EditorBrowsableAttribute(EditorBrowsableState.Never)>]
+    [<CompilerMessageAttribute("This method is intended for use in generated code only.",
+                               10001,
+                               IsHidden = true,
+                               IsError = false)>]
+    member _.GetSchema(id: string) = schemas |> Map.find id
+
+    /// <exclude />
+    [<EditorBrowsableAttribute(EditorBrowsableState.Never)>]
+    [<CompilerMessageAttribute("This method is intended for use in generated code only.",
+                               10001,
+                               IsHidden = true,
+                               IsError = false)>]
+    member _.GetJsonLd(id: string) = jsonLd |> Map.find id
+
 /// Underlying representation of table types generated by HtmlProvider
 type HtmlTable<'RowType> internal (name: string, headers: string[] option, values: 'RowType[], html: HtmlNode) =
 
diff --git a/tests/FSharp.Data.Core.Tests/BaseTypesHtmlDocument.fs b/tests/FSharp.Data.Core.Tests/BaseTypesHtmlDocument.fs
index e2ee8c458..b56bcf311 100644
--- a/tests/FSharp.Data.Core.Tests/BaseTypesHtmlDocument.fs
+++ b/tests/FSharp.Data.Core.Tests/BaseTypesHtmlDocument.fs
@@ -255,4 +255,89 @@ let ``HtmlDocument.Create processes multiple definition lists correctly`` () =
     htmlDoc.Html.ToString() |> should contain "Term A"
     htmlDoc.Html.ToString() |> should contain "Definition A"
     htmlDoc.Html.ToString() |> should contain "Term B"
-    htmlDoc.Html.ToString() |> should contain "Definition B"
\ No newline at end of file
+    htmlDoc.Html.ToString() |> should contain "Definition B"
+// ============================================
+// JSON-LD Parsing Tests
+// ============================================
+
+[<Test>]
+let ``HtmlDocument.Create parses JSON-LD script blocks`` () =
+    let htmlContent =
+        """<html>
+<head>
+  <script type="application/ld+json">
+  {"@context":"https://schema.org","@type":"Article","name":"Test Article","headline":"A test","url":"https://example.com"}
+  </script>
+</head>
+<body></body>
+</html>"""
+
+    use reader = new StringReader(htmlContent)
+    let htmlDoc = HtmlDocument.Create(false, reader)
+    let article = htmlDoc.GetJsonLd("Article")
+    article.Items |> should haveLength 1
+    article.Items.[0].Properties |> Map.find "name" |> should equal "Test Article"
+
+[<Test>]
+let ``HtmlDocument.Create returns empty JSON-LD when no script blocks present`` () =
+    let htmlContent = "<html><body><p>No JSON-LD here</p></body></html>"
+
+    use reader = new StringReader(htmlContent)
+    let htmlDoc = HtmlDocument.Create(false, reader)
+    (fun () -> htmlDoc.GetJsonLd("Article") |> ignore) |> should throw typeof<System.Collections.Generic.KeyNotFoundException>
+
+[<Test>]
+let ``HtmlDocument.Create handles multiple JSON-LD script blocks of different types`` () =
+    let htmlContent =
+        """<html>
+<head>
+  <script type="application/ld+json">
+  {"@context":"https://schema.org","@type":"Article","name":"My Article","headline":"A headline"}
+  </script>
+  <script type="application/ld+json">
+  {"@context":"https://schema.org","@type":"WebSite","name":"My Site","url":"https://example.com"}
+  </script>
+</head>
+<body></body>
+</html>"""
+
+    use reader = new StringReader(htmlContent)
+    let htmlDoc = HtmlDocument.Create(false, reader)
+    htmlDoc.GetJsonLd("Article").Items |> should haveLength 1
+    htmlDoc.GetJsonLd("WebSite").Items |> should haveLength 1
+    htmlDoc.GetJsonLd("WebSite").Items.[0].Properties |> Map.find "url" |> should equal "https://example.com"
+
+[<Test>]
+let ``JSON-LD parser handles array top-level`` () =
+    let htmlContent =
+        """<html>
+<head>
+  <script type="application/ld+json">
+  [{"@context":"https://schema.org","@type":"Article","name":"Item 1"},
+   {"@context":"https://schema.org","@type":"Article","name":"Item 2"}]
+  </script>
+</head>
+<body></body>
+</html>"""
+
+    use reader = new StringReader(htmlContent)
+    let htmlDoc = HtmlDocument.Create(false, reader)
+    htmlDoc.GetJsonLd("Article").Items |> should haveLength 2
+
+[<Test>]
+let ``JSON-LD Raw property contains the original JSON`` () =
+    let htmlContent =
+        """<html>
+<head>
+  <script type="application/ld+json">
+  {"@context":"https://schema.org","@type":"Article","name":"Test","description":"Desc"}
+  </script>
+</head>
+<body></body>
+</html>"""
+
+    use reader = new StringReader(htmlContent)
+    let htmlDoc = HtmlDocument.Create(false, reader)
+    let item = htmlDoc.GetJsonLd("Article").Items.[0]
+    item.Raw |> should contain "Test"
+    item.Raw |> should contain "Desc"
diff --git a/tests/FSharp.Data.Core.Tests/HtmlRuntimeTypes.fs b/tests/FSharp.Data.Core.Tests/HtmlRuntimeTypes.fs
index e7262923f..4a7e907df 100644
--- a/tests/FSharp.Data.Core.Tests/HtmlRuntimeTypes.fs
+++ b/tests/FSharp.Data.Core.Tests/HtmlRuntimeTypes.fs
@@ -98,4 +98,104 @@ let ``HtmlDefinitionList record ToString should handle empty definitions`` () =
     result |> should contain name
 
 // Note: Generic HtmlList<T> and HtmlTable<T> tests are complex due to internal type usage
-// The record types (HtmlList and HtmlDefinitionList) above provide good coverage for the 0% areas
\ No newline at end of file
+// The record types (HtmlList and HtmlDefinitionList) above provide good coverage for the 0% areas
+// ============================================
+// Schema.org Microdata Tests
+// ============================================
+
+[<Test>]
+let ``getSchemas returns empty list when no microdata present`` () =
+    let doc = HtmlDocument.Parse "<html><body><p>No microdata here.</p></body></html>"
+    let schemas = HtmlRuntime.getSchemas doc
+    schemas |> List.length |> should equal 0
+
+[<Test>]
+let ``getSchemas finds itemscope items and groups by itemtype`` () =
+    let html = """
+<html><body>
+  <div itemscope itemtype="http://schema.org/Person">
+    <span itemprop="name">Jane Doe</span>
+    <span itemprop="jobTitle">Engineer</span>
+  </div>
+</body></html>"""
+
+    let doc = HtmlDocument.Parse html
+    let schemas = HtmlRuntime.getSchemas doc
+    schemas |> should haveLength 1
+    let group = schemas.[0]
+    group.TypeUrl |> should equal "http://schema.org/Person"
+    group.Name |> should equal "Person"
+    group.Items |> should haveLength 1
+    group.Items.[0].Properties |> Map.find "name" |> should equal "Jane Doe"
+    group.Items.[0].Properties |> Map.find "jobTitle" |> should equal "Engineer"
+
+[<Test>]
+let ``getSchemas groups multiple items of same type`` () =
+    let html = """
+<html><body>
+  <div itemscope itemtype="http://schema.org/Product">
+    <span itemprop="name">Widget A</span>
+    <span itemprop="price">9.99</span>
+  </div>
+  <div itemscope itemtype="http://schema.org/Product">
+    <span itemprop="name">Widget B</span>
+  </div>
+</body></html>"""
+
+    let doc = HtmlDocument.Parse html
+    let schemas = HtmlRuntime.getSchemas doc
+    schemas |> should haveLength 1
+    let group = schemas.[0]
+    group.Items |> should haveLength 2
+    group.Items.[0].Properties |> Map.find "name" |> should equal "Widget A"
+    group.Items.[1].Properties |> Map.find "name" |> should equal "Widget B"
+    group.Properties |> should contain "name"
+    group.Properties |> should contain "price"
+
+[<Test>]
+let ``getSchemas creates separate groups for different schema types`` () =
+    let html = """
+<html><body>
+  <div itemscope itemtype="http://schema.org/Person">
+    <span itemprop="name">John</span>
+  </div>
+  <div itemscope itemtype="http://schema.org/Organization">
+    <span itemprop="name">Acme Corp</span>
+  </div>
+</body></html>"""
+
+    let doc = HtmlDocument.Parse html
+    let schemas = HtmlRuntime.getSchemas doc
+    schemas |> should haveLength 2
+
+[<Test>]
+let ``getSchemas uses content attribute for meta elements`` () =
+    let html = """
+<html><body>
+  <div itemscope itemtype="http://schema.org/Event">
+    <meta itemprop="startDate" content="2024-01-15">
+  </div>
+</body></html>"""
+
+    let doc = HtmlDocument.Parse html
+    let schemas = HtmlRuntime.getSchemas doc
+    schemas.[0].Items.[0].Properties |> Map.find "startDate" |> should equal "2024-01-15"
+
+[<Test>]
+let ``HtmlSchemaGroup ToString formats correctly`` () =
+    let node = HtmlNode.NewText "dummy"
+
+    let item =
+        { HtmlSchemaItem.Properties = Map.ofList [ "name", "Alice" ]
+          Html = node }
+
+    let group =
+        { HtmlSchemaGroup.Name = "Person"
+          TypeUrl = "http://schema.org/Person"
+          Items = [| item |]
+          Properties = [| "name" |] }
+
+    let result = group.ToString()
+    result |> should contain "Person"
+    result |> should contain "name"
+    result |> should contain "Alice"
diff --git a/tests/FSharp.Data.DesignTime.Tests/expected/Html,ebay_cars.htm,False,False,.expected b/tests/FSharp.Data.DesignTime.Tests/expected/Html,ebay_cars.htm,False,False,.expected
index cbfaf92ff..c5604c4e8 100644
--- a/tests/FSharp.Data.DesignTime.Tests/expected/Html,ebay_cars.htm,False,False,.expected
+++ b/tests/FSharp.Data.DesignTime.Tests/expected/Html,ebay_cars.htm,False,False,.expected
@@ -28,6 +28,9 @@ class HtmlProvider : FDR.BaseTypes.HtmlDocument
     static member Parse: text:string -> HtmlProvider
     HtmlDocument.Create(false, ((new StringReader(text)) :> TextReader))
 
+    member Schemas: HtmlProvider+SchemasContainer with get
+    this
+
     member Tables: HtmlProvider+TablesContainer with get
     this
 
@@ -94,6 +97,11 @@ class HtmlProvider+ListsContainer : FDR.BaseTypes.HtmlDocument
     HtmlList<_>.Create(rowConverter, this, "See also")
 
 
+class HtmlProvider+SchemasContainer : FDR.BaseTypes.HtmlDocument
+    member SearchResultsPage: HtmlProvider+HtmlProvider+SearchResultsPage[] with get
+    this.GetSchema("SearchResultsPage").Items
+
+
 class HtmlProvider+TablesContainer : FDR.BaseTypes.HtmlDocument
     member ``Additional site navigation``: HtmlProvider+AdditionalSiteNavigation with get
     let rowConverter = new Func<_,_>(fun (row:string[]) -> 
@@ -124,6 +132,15 @@ class HtmlProvider+Menu4 : FDR.BaseTypes.HtmlList<string>
 
 class HtmlProvider+Menu5 : FDR.BaseTypes.HtmlList<int>
 
+class HtmlProvider+SearchResultsPage : FDR.HtmlSchemaItem
+    member Html: HtmlNode with get
+    this.Html
+
+    member Offers: string with get
+    this.Properties |> (MapModule.TryFind "offers" table) |> let value = ""
+                                                             Lambda (option, Call (None, DefaultValue, [value, option]))
+
+
 class HtmlProvider+SeeAlso : FDR.BaseTypes.HtmlList<string>
 
 class HtmlProvider+AdditionalSiteNavigation+Row : string * string
diff --git a/tests/FSharp.Data.DesignTime.Tests/expected/Html,imdb_chart.htm,False,False,.expected b/tests/FSharp.Data.DesignTime.Tests/expected/Html,imdb_chart.htm,False,False,.expected
index ed0343fde..dc8cf435d 100644
--- a/tests/FSharp.Data.DesignTime.Tests/expected/Html,imdb_chart.htm,False,False,.expected
+++ b/tests/FSharp.Data.DesignTime.Tests/expected/Html,imdb_chart.htm,False,False,.expected
@@ -28,6 +28,9 @@ class HtmlProvider : FDR.BaseTypes.HtmlDocument
     static member Parse: text:string -> HtmlProvider
     HtmlDocument.Create(false, ((new StringReader(text)) :> TextReader))
 
+    member Schemas: HtmlProvider+SchemasContainer with get
+    this
+
     member Tables: HtmlProvider+TablesContainer with get
     this
 
@@ -70,6 +73,11 @@ class HtmlProvider+ListsContainer : FDR.BaseTypes.HtmlDocument
     HtmlList<_>.Create(rowConverter, this, "YOUR WATCHLIST")
 
 
+class HtmlProvider+SchemasContainer : FDR.BaseTypes.HtmlDocument
+    member AggregateRating: HtmlProvider+HtmlProvider+AggregateRating[] with get
+    this.GetSchema("AggregateRating").Items
+
+
 class HtmlProvider+TablesContainer : FDR.BaseTypes.HtmlDocument
     member ``Take The Quiz!``: HtmlProvider+TakeTheQuiz with get
     let rowConverter = new Func<_,_>(fun (row:string[]) -> 
@@ -106,6 +114,23 @@ class HtmlProvider+TablesContainer : FDR.BaseTypes.HtmlDocument
     HtmlTable<_>.Create(rowConverter, this, "Top 250", true)
 
 
+class HtmlProvider+AggregateRating : FDR.HtmlSchemaItem
+    member BestRating: string with get
+    this.Properties |> (MapModule.TryFind "bestRating" table) |> let value = ""
+                                                                 Lambda (option, Call (None, DefaultValue, [value, option]))
+
+    member Html: HtmlNode with get
+    this.Html
+
+    member RatingCount: string with get
+    this.Properties |> (MapModule.TryFind "ratingCount" table) |> let value = ""
+                                                                  Lambda (option, Call (None, DefaultValue, [value, option]))
+
+    member RatingValue: string with get
+    this.Properties |> (MapModule.TryFind "ratingValue" table) |> let value = ""
+                                                                  Lambda (option, Call (None, DefaultValue, [value, option]))
+
+
 class HtmlProvider+ConsumerMainNav : FDR.BaseTypes.HtmlList<string>
 
 class HtmlProvider+GetDiscovered : FDR.BaseTypes.HtmlList<string>
diff --git a/tests/FSharp.Data.DesignTime.Tests/expected/Html,zoopla.html,False,False,.expected b/tests/FSharp.Data.DesignTime.Tests/expected/Html,zoopla.html,False,False,.expected
index 8db4418d1..4f1c3a30f 100644
--- a/tests/FSharp.Data.DesignTime.Tests/expected/Html,zoopla.html,False,False,.expected
+++ b/tests/FSharp.Data.DesignTime.Tests/expected/Html,zoopla.html,False,False,.expected
@@ -28,6 +28,9 @@ class HtmlProvider : FDR.BaseTypes.HtmlDocument
     static member Parse: text:string -> HtmlProvider
     HtmlDocument.Create(false, ((new StringReader(text)) :> TextReader))
 
+    member Schemas: HtmlProvider+SchemasContainer with get
+    this
+
     member Tables: HtmlProvider+TablesContainer with get
     this
 
@@ -130,6 +133,11 @@ class HtmlProvider+ListsContainer : FDR.BaseTypes.HtmlDocument
     HtmlList<_>.Create(rowConverter, this, "Property type")
 
 
+class HtmlProvider+SchemasContainer : FDR.BaseTypes.HtmlDocument
+    member WebPage: HtmlProvider+HtmlProvider+WebPage[] with get
+    this.GetSchema("WebPage").Items
+
+
 class HtmlProvider+TablesContainer : FDR.BaseTypes.HtmlDocument
     member ``Currently available to rent in London``: HtmlProvider+CurrentlyAvailableToRentInLondon with get
     let rowConverter = new Func<_,_>(fun (row:string[]) -> 
@@ -180,6 +188,19 @@ class HtmlProvider+PropertyFeatures : FDR.BaseTypes.HtmlList<string>
 
 class HtmlProvider+PropertyType : FDR.BaseTypes.HtmlList<string>
 
+class HtmlProvider+WebPage : FDR.HtmlSchemaItem
+    member Breadcrumb: string with get
+    this.Properties |> (MapModule.TryFind "breadcrumb" table) |> let value = ""
+                                                                 Lambda (option, Call (None, DefaultValue, [value, option]))
+
+    member Html: HtmlNode with get
+    this.Html
+
+    member Name: string with get
+    this.Properties |> (MapModule.TryFind "name" table) |> let value = ""
+                                                           Lambda (option, Call (None, DefaultValue, [value, option]))
+
+
 class HtmlProvider+CurrentlyAvailableToRentInLondon+Row : string * int * int * int * float
     member ``1 bed``: int with get
     (let _,t2,_,_,_ = this in t2)
diff --git a/tests/FSharp.Data.DesignTime.Tests/expected/Html,zoopla2.html,False,False,.expected b/tests/FSharp.Data.DesignTime.Tests/expected/Html,zoopla2.html,False,False,.expected
index 47eb0fa4d..d88cc1779 100644
--- a/tests/FSharp.Data.DesignTime.Tests/expected/Html,zoopla2.html,False,False,.expected
+++ b/tests/FSharp.Data.DesignTime.Tests/expected/Html,zoopla2.html,False,False,.expected
@@ -28,6 +28,9 @@ class HtmlProvider : FDR.BaseTypes.HtmlDocument
     static member Parse: text:string -> HtmlProvider
     HtmlDocument.Create(false, ((new StringReader(text)) :> TextReader))
 
+    member Schemas: HtmlProvider+SchemasContainer with get
+    this
+
     member Tables: HtmlProvider+TablesContainer with get
     this
 
@@ -130,6 +133,11 @@ class HtmlProvider+ListsContainer : FDR.BaseTypes.HtmlDocument
     HtmlList<_>.Create(rowConverter, this, "Property type")
 
 
+class HtmlProvider+SchemasContainer : FDR.BaseTypes.HtmlDocument
+    member SearchResultsPage: HtmlProvider+HtmlProvider+SearchResultsPage[] with get
+    this.GetSchema("SearchResultsPage").Items
+
+
 class HtmlProvider+TablesContainer : FDR.BaseTypes.HtmlDocument
     member ``Currently available to rent in London``: HtmlProvider+CurrentlyAvailableToRentInLondon with get
     let rowConverter = new Func<_,_>(fun (row:string[]) -> 
@@ -180,6 +188,11 @@ class HtmlProvider+List9 : FDR.BaseTypes.HtmlList<string>
 
 class HtmlProvider+PropertyType : FDR.BaseTypes.HtmlList<string>
 
+class HtmlProvider+SearchResultsPage : FDR.HtmlSchemaItem
+    member Html: HtmlNode with get
+    this.Html
+
+
 class HtmlProvider+CurrentlyAvailableToRentInLondon+Row : string * int * int * int * float
     member ``1 bed``: int with get
     (let _,t2,_,_,_ = this in t2)
diff --git a/tests/FSharp.Data.Tests/HtmlProvider.fs b/tests/FSharp.Data.Tests/HtmlProvider.fs
index 95b33ee7d..30a56a435 100644
--- a/tests/FSharp.Data.Tests/HtmlProvider.fs
+++ b/tests/FSharp.Data.Tests/HtmlProvider.fs
@@ -372,3 +372,160 @@ let ``Can infer DateTime and DateTimeOffset types correctly`` () =
     table.Rows.[0].DateOnly.GetType() |> should equal typeof<DateOnly>
     table.Rows.[0].MixedDate.GetType() |> should equal typeof<DateTime>
     table.Rows.[0].DateWithOffset.GetType() |> should equal typeof<DateTimeOffset>
+
+// ============================================
+// Schema.org Microdata via HtmlProvider
+// ============================================
+
+[<Literal>]
+let schemaMicrodata = """<html><body>
+  <div itemscope itemtype="http://schema.org/Person">
+    <span itemprop="name">Jane Smith</span>
+    <span itemprop="jobTitle">Software Engineer</span>
+    <a itemprop="url" href="https://example.com">Homepage</a>
+  </div>
+  <div itemscope itemtype="http://schema.org/Person">
+    <span itemprop="name">Bob Jones</span>
+    <span itemprop="jobTitle">Designer</span>
+  </div>
+</body></html>"""
+
+type SchemaMicrodataHtml = HtmlProvider<schemaMicrodata>
+
+[<Test>]
+let ``HtmlProvider exposes Schemas container for microdata`` () =
+    let doc = SchemaMicrodataHtml.GetSample()
+    let people = doc.Schemas.Person
+    people |> should not' (be null)
+
+[<Test>]
+let ``HtmlProvider Schemas.Person returns all items`` () =
+    let doc = SchemaMicrodataHtml.GetSample()
+    let people = doc.Schemas.Person
+    people |> should haveLength 2
+
+[<Test>]
+let ``HtmlProvider Schemas.Person items have typed properties`` () =
+    let doc = SchemaMicrodataHtml.GetSample()
+    let people = doc.Schemas.Person
+    people.[0].Name |> should equal "Jane Smith"
+    people.[0].JobTitle |> should equal "Software Engineer"
+    people.[0].Url |> should equal "https://example.com"
+    people.[1].Name |> should equal "Bob Jones"
+
+// ============================================
+// JSON-LD via HtmlProvider
+// ============================================
+
+[<Literal>]
+let jsonLdArticle =
+    """<html>
+<head>
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    "name": "F# Data Library",
+    "headline": "F# Data: Library for Data Access",
+    "description": "A library for working with structured data",
+    "url": "https://fsprojects.github.io/FSharp.Data",
+    "datePublished": "2012-01-01",
+    "dateModified": "2024-01-01"
+  }
+  </script>
+</head>
+<body><p>Content here</p></body>
+</html>"""
+
+type JsonLdArticleHtml = HtmlProvider<jsonLdArticle>
+
+[<Test>]
+let ``HtmlProvider exposes JsonLd container for JSON-LD`` () =
+    let doc = JsonLdArticleHtml.GetSample()
+    let articles = doc.JsonLd.Article
+    articles |> should not' (be null)
+
+[<Test>]
+let ``HtmlProvider JsonLd.Article returns items`` () =
+    let doc = JsonLdArticleHtml.GetSample()
+    let articles = doc.JsonLd.Article
+    articles |> should haveLength 1
+
+[<Test>]
+let ``HtmlProvider JsonLd.Article items have typed properties`` () =
+    let doc = JsonLdArticleHtml.GetSample()
+    let article = doc.JsonLd.Article.[0]
+    article.Name |> should equal "F# Data Library"
+    article.Headline |> should equal "F# Data: Library for Data Access"
+    article.Url |> should equal "https://fsprojects.github.io/FSharp.Data"
+    article.DatePublished |> should equal "2012-01-01"
+
+[<Test>]
+let ``HtmlProvider JsonLd.Article item has Raw property`` () =
+    let doc = JsonLdArticleHtml.GetSample()
+    let article = doc.JsonLd.Article.[0]
+    article.Raw |> should contain "F# Data Library"
+
+[<Literal>]
+let jsonLdMultipleTypes =
+    """<html>
+<head>
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "WebPage",
+    "name": "My Page",
+    "url": "https://example.com/page"
+  }
+  </script>
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    "name": "My Article",
+    "headline": "An interesting article",
+    "datePublished": "2025-01-01"
+  }
+  </script>
+</head>
+<body></body>
+</html>"""
+
+type JsonLdMultiTypeHtml = HtmlProvider<jsonLdMultipleTypes>
+
+[<Test>]
+let ``HtmlProvider JsonLd supports multiple type groups`` () =
+    let doc = JsonLdMultiTypeHtml.GetSample()
+    doc.JsonLd.WebPage |> should haveLength 1
+    doc.JsonLd.Article |> should haveLength 1
+    doc.JsonLd.WebPage.[0].Name |> should equal "My Page"
+    doc.JsonLd.Article.[0].Name |> should equal "My Article"
+
+[<Literal>]
+let jsonLdMixed =
+    """<html>
+<head>
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    "name": "Mixed Page",
+    "description": "A page with both JSON-LD and a table"
+  }
+  </script>
+</head>
+<body>
+  <table>
+    <tr><th>Column1</th><th>Column2</th></tr>
+    <tr><td>Value1</td><td>Value2</td></tr>
+  </table>
+</body>
+</html>"""
+
+type JsonLdMixedHtml = HtmlProvider<jsonLdMixed>
+
+[<Test>]
+let ``HtmlProvider can combine JSON-LD and table extraction`` () =
+    let doc = JsonLdMixedHtml.GetSample()
+    doc.JsonLd.Article.[0].Name |> should equal "Mixed Page"
+    doc.Tables.Table1.Rows |> should haveLength 1