Abstract

HTML microdata [ MICRODATA ] is an extension to HTML used to embed machine-readable data into HTML documents. Whereas the microdata specification describes a means of markup, the output format is JSON. This specification describes processing rules that may be used to extract RDF [ RDF-CONCEPTS RDF11-CONCEPTS ] from an HTML document containing microdata.

Status of This Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

This document is an experimental work in progress. The concepts described herein are intended to provide guidance for a possible future Working Group chartered to provide a Recommendation for this transformation. As a consequence, implementers of this specification, either producers or consumers, should note that it may change prior to any possible publication as a Recommendation.

This Working Draft is an update of the W3C Interest Group Note , published in March October 2012. This update adds simplifies processing using the Vocabulary Expansion following mechanisms:

The intention is to publish this draft as a new version of the Interest Group Note after gathering and incorporating community input.

This document was published by the Semantic Web Interest Group as an Interest Group Note. If you wish to make comments regarding this document, please send them to semantic-web@w3.org ( subscribe , archives ). All feedback is comments are welcome.

Publication as an Interest Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

The disclosure obligations of the Participants of this group are described in the charter .

This document is governed by the 1 August 2014 W3C Process Document .

Table of Contents

1. Introduction

This section is non-normative.

This document describes a means of transforming HTML containing microdata into RDF. HTML Microdata [ MICRODATA ] is an extension to HTML used to embed machine-readable data to HTML documents. This specification describes transformation directly to RDF [ RDF-CONCEPTS RDF11-CONCEPTS ].

Note

There are a variety of ways in which a mapping from microdata to RDF might be configured to give a result that is closer to the required result for a particular vocabulary. This specification defines terms that can be used as hooks for vocabulary-specific behavior, which could be defined within a registry or on an implementation-defined basis. However, the HTML Data TF recommends the adoption of a single method of mapping in which every vocabulary is treated as if:

propertyURI is set to vocabulary multipleValues is set to unordered

For background on the trade-offs between these options, see http://www.w3.org/wiki/Mapping_Microdata_to_RDF and GitHub Issues .

1.1 Background

This section is non-normative.

Microdata [ MICRODATA ] is a way of embedding data in HTML documents using attributes. The HTML DOM is extended to provide an API for accessing microdata information, and the microdata specification defines how to generate a JSON representation from microdata markup.

Mapping microdata to RDF enables consumers to merge data expressed in other RDF-based formats with microdata. It facilitates the use of RDF vocabularies within microdata, and enables microdata to be used with the full RDF toolchain. Some use cases for this mapping are described in Section 1.2 below.

Microdata's data model does not align neatly with RDF.

Thus, in some places the needs of RDF consumers violate requirements of the microdata specification. This specification highlights where such violations occur and the reasons for them.

This specification allows for vocabulary -specific rules that affect the generation of property URIs and value serializations. This is facilitated by a registry that associates URIs with specific rules based on matching itemtype values against registered URI prefixes do determine a vocabulary and potentially vocabulary-specific processing rules.

This specification also assumes that consumers of RDF generated from microdata may have to process the results in order to, for example, assign appropriate datatypes to property value s. values .

1.2 Use Cases

This section is non-normative.

During the period of the task force, a number of use cases were put forth for the use of microdata in generating RDF:

1.3 Issues

This section is non-normative.

Decisions or open issues in the specification are tracked on the Task Force GitHub Issue Tracker . These include the following:

Vocabulary specific parsing for Microdata.

Experimental Feature

Experimental support itemprop-reverse . This specification attempts to create generic rules for processing microdata with typical RDF vocabularies. A registry allows for exceptions to the default processing rules for certain well-known vocabularies. Issue 2 attribute is not part of [ MICRODATA Should Microdata-RDF generate XMLLiteral values. This issue has been closed with no change ] and is included as this would violate microdata's data model. Issue 3 Should an experimental feature. Specific feedback from the registry allow property datatype specification. The consensus community is that datatypes are only derived from HTML semantics, so that only <time> values have a datatype other than plain. Issue 4 Should requested. Based on addoption, the registry allow a name or URL to attribute may be used as an alias considered for itemid . inclusion in forthcoming versions of [ MICRODATA ] and this note.

The purpose of this specification is to provide input to a future working group that can make decisions about the need for a registry and the details of processing. Among the options investigated by the Task Force are the following:

More examples and explanatory information are available in [ MICRODATA-RDF-SUPPLEMENT ], which may be updated from time to time.

2. Attributes and Syntax

The microdata specification [ MICRODATA ] defines a number of attributes and the way in which those attributes are to be interpreted. The microdata DOM API provides methods and attributes for retrieving microdata from the HTML DOM.

For reference, attributes used for specifying and retrieving HTML microdata are referenced here:

itemid
An attribute containing a URL used to identify the subject of triples associated with this item . (See Items itemid in [ MICRODATA ]).
itemprop
An attribute used to identify one or more name names s of an item s. items . An itemprop contains a space separated list of name names s which may either by absolute URL URLs s or terms associated with the type of the item as defined by the referencing item 's item type . (See Items itemprop in [ MICRODATA ]).
itemref
An additional attribute on an element that references additional elements containing property definitions to be applied to the referencing item . (See Items itemref in [ MICRODATA ]).
itemscope
An boolean attribute identifying an element as an item . (See Items itemscope in [ MICRODATA ]).
itemtype
An additional attribute on an element used to specify one or more types of an item . The item type of an item is the first value returned from element.itemType on the element. The item type is also used to resolve non-URL name names s to absolute URL s. URLs . Available through the Microdata DOM API as element.itemType . (See Items itemtype in [ MICRODATA ]).

In RDF, it is common for people to shorten vocabulary terms via abbreviated URIs that use a 'prefix' and a 'reference'. throughout this document assume that the following vocabulary prefixes have been defined:

dc: http://purl.org/dc/terms/
md: http://www.w3.org/ns/md#
rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns#
rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns#
rdfa: http://www.w3.org/ns/rdfa#
xsd: http://www.w3.org/2001/XMLSchema#

3. Vocabulary Registry

This section is non-normative.

In a perfect world, all processors would be able to generate the same output for a given input without regards to the requirements of a particular vocabulary . However, microdata doesn't provide sufficient syntactic help in making these decisions. Different vocabularies have different needs.

The registry is located at the namespace defined for microdata: http://www.w3.org/ns/md in a variety of formats. Under control of a runtime option, a processor should use another provided by reference, to affect processing.

The registry associates a URI prefix with one or more key-value pairs denoting processor behavior. A hypothetical JSON representation of such a registry might be the following:

{ "http://schema.org/": { "propertyURI": "vocabulary", "multipleValues": "unordered", "properties": { "tracks": {"multipleValues": "list"} } }, "http://microformats.org/profile/hcard": { "propertyURI": "vocabulary", "multipleValues": "list", "properties" { "url": {"multipleValues": "unordered"} } }
Example 1
{
  "http://schema.org/": {
    "properties": {
      "additionalType": {"subPropertyOf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}
    },
    "http://microformats.org/profile/hcard": {}
  }

}

This structure associates mappings for two URIs, URIs: http://schema.org/ and http://microformats.org/profile/hcard . Items having an item type with a URI prefix from this registry use the the rules described for that prefix within the scope of that item type . This For http://schema.org/ , this mapping currently defines two rules: propertyURI and a single property: multipleValues additionalType with values a value to indicate specific behavior. It also allows overrides on a per-property basis; the item properties key associates an individual name with overrides for default behavior. The interpretation of these rules is defined in the following sections. If an item has no current type or the registry contains no URI prefix matching current type , a conforming processor must MUST use the default values defined for these rules.

Note The concept of a registry , including a hypothetical format, location and updating rules is presented as an abstract concept useful for describing the function of a microdata processor. There are issues surrounding update frequency, URL naming, and how updates are authorized. This spec just considers the semantic content of such a registry and how it can be used to affect processing without defining its representation or update policies.

3.1 Property URI Generation

This section is non-normative.

For name names s which are not absolute URL s, the propertyURI rule URLs , this section defines the algorithm for generating an absolute URL given an evaluation context including a current type , current name and current vocabulary .

The procedure for generating property URIs is defined in Generate Predicate URI .

Possible values for propertyURI are the following: contextual The contextual URI generation scheme guarantees that generated property URIs are unique based on the value of current name . This is required as the microdata data model requires that name s are associated with specific items and do not have a global scope. (See Step 5 in Generate Predicate URI ). URI creation uses a base URI with query parameters to indicate the in-scope type and name list. Consider the following example: <span itemscope itemtype="http://microformats.org/profile/hcard"> <span itemprop="n" itemscope> <span itemprop="given-name"> Princeton </span> </span> </span> The first name n generates the URI http://www.w3.org/ns/md?type=http://microformats.org/profile/hcard?prop=n . However, the included name given-name is included in untyped item. The inherited property URI is used to create a new property URI: http://www.w3.org/ns/md?type=http://microformats.org/profile/hcard?prop=n.given-name . This scheme is compatible with the needs of other RDF serialization formats such as RDF/XML [ RDF-SYNTAX-GRAMMAR ], which rely on QNames for expressing properties. For example, the generated property URIs can be split as follows: <rdf:Description xmlns:hcard="http://www.w3.org/ns/md?type=http://microformats.org/profile/hcard?prop=" rdf:type="http://microformats.org/profile/hcard"> <hcard:n> <rdf:Description> <hcard:n.given-name> Princeton </hcard:n.given-name> </rdf:Description> </hcard:n> </rdf:Description> Looking at another example: <div itemscope itemtype="http://schema.org/Person"> <h2 itemprop="name">Jeni</h2> </div> This would generate http://www.w3.org/ns/md?type=http://schema.org/Person&prop=name . vocabulary The vocabulary URI generation scheme appends name names s that are not absolute URL URLs s to the URI prefix . When generating property URIs, if the URI prefix does not end with a '/' or '#', a '#' is appended to the URI prefix . (See Step 4 in Generate Predicate URI .)

URI creation uses a base URL with query parameters to indicate the in-scope type and name list. Consider the following example:

<span itemscope itemtype="http://microformats.org/profile/hcard"> <span itemprop="n" itemscope> <span itemprop="given-name"> Princeton </span> </span>
Example 2
<span itemscope itemtype="http://microformats.org/profile/hcard">
  <span itemprop="n" itemscope>
    <span itemprop="given-name">
      Princeton
    </span>
  </span>

</span>

Given the URI prefix http://microformats.org/profile/hcard , this would generate http://microformats.org/profile/hcard#n and http://microformats.org/profile/hcard#given-name . Note that the '#' is automatically added as a separator.

Looking at another example:

<div itemscope itemtype="http://schema.org/Person"> <h2 itemprop="name">Jeni</h2>
Example 3
<div itemscope itemtype="http://schema.org/Person">
  <h2 itemprop="name">Jeni</h2>

</div>

Given the URI prefix http://schema.org/ , this would generate http://schema.org/name . Note that if the itemtype were http://schema.org/Person/Teacher , this would generate the same property URI.

If the registry contains no match for current type implementations MUST act as if there is a URI prefix made from the first itemtype value by stripping either the fragment content or last path segment , if the value has no fragment (See [ RFC3986 ]).

The vocabulary URI prefix is made from the first itemtype value by stripping either the fragment content or last path segment , if the value has no fragment (See [ RFC3986 ]).

Note

Deconstructing the itemtype URL to create or identify a vocabulary URI is a violation of the microdata specification which is necessary to support the use of existing vocabularies designed for use with RDF, and shared or inherited properties within all vocabularies.

The default value of propertyURI is vocabulary . <div itemscope itemtype="http://schema.org/Book"> <h2 itemprop="title">Just a Geek</h2>
Example 4
<div itemscope itemtype="http://example.org/Book">
  <h2 itemprop="title">Just a Geek</h2>

</div>

In this example, assuming no matching entry in the registry , the URI prefix is constructed by removing the last path segment , leaving the URI http://schema.org/ http://example.org/ . As there is no explicit propertyURI , the default vocabulary is used, and the The resulting property URI would be http://schema.org/title http://example.org/title .

3.2 Value Ordering

This section If there is non-normative. For items having multiple values for a given property no in-scope itemtype , property URIs are generated using the multipleValues rule defines base URI of the algorithm for serializing these values. Microdata uses document order when generating property value s, as defined in Microdata DOM API as element.itemValue . However, many RDF vocabularies expect multiple values to be generated as triples sharing a common subject and predicate. In some cases, it may be useful to retain value ordering. The procedure for generating property value s is defined in Generate Property Values . Possible values for multipleValues are the following: unordered Values are serialized without ordering using a common subject and predicate. (See Step 7 in Generate Property Values ). list Multi-valued itemprop s are serialized using an RDF Collection . (See Step 8 in Generate Property Values name ). An example of how this might be specified in as a registry is fragment Consider the following: following example:

{ "http://schema.org/": { "propertyURI": "vocabulary", }, "http://microformats.org/profile/hcard": { "propertyURI": "vocabulary", } }
Example 5
<div itemscope>
<p itemscope itemprop='bar'>
  <span itemprop='baz'>Baz</span>
</p>
</div>

Additionally, some vocabularies may wish to specify this on a per-property basis. For example, within http://schema.org/MusicPlaylist If the document is located at tracks property might depend on http://example/author , the order of values to to reproduce associated MusicRecording values. { "http://schema.org/": { "propertyURI": "vocabulary", "multipleValues": "unordered", "properties": { "tracks": {"multipleValues": "list"} } } } The properties key takes a JSON Object as a value, which in turn has keys for each property that is to be given alternate semantics. Each name is implicitly expanded to it's URI representation as defined in Generate Predicate URI , so that the behavior is bar generates the same whether or not URI http://example/author#bar . However, the included name baz is listed as an absolute URL . included in untyped item. The default value of multipleValues inherited property URI is used to create a new property URI: unordered http://example/author#baz .

Note

This scheme is compatible with the needs of other RDF serialization formats such as RDF/XML [ RDF-SYNTAX-GRAMMAR An alternative mechanism would output ], which rely on both QNames unordered and ordered values, to allow an application to choose the most useful representation. for expressing properties. For example, consider the following: <div itemscope itemtype="http://schema.org/MusicPlaylist"> <span itemprop="name">Classic Rock Playlist</span> <meta itemprop="numTracks" content="2"/> <p>Including works by <span itemprop="byArtist">Lynard Skynard</span> and <span itemprop="byArtist">AC/DC</span></p>. <div itemprop="tracks" itemscope itemtype="http://schema.org/MusicRecording"> 1.<span itemprop="name">Sweet Home Alabama</span> - <span itemprop="byArtist">Lynard Skynard</span> <link href="sweet-home-alabama" itemprop="url" /> </div> <div itemprop="tracks" itemscope itemtype="http://schema.org/MusicRecording"> 2.<span itemprop="name">Shook you all Night Long</span> - <span itemprop="byArtist">AC/DC</span> <link href="shook-you-all-night-long" itemprop="url" /> </div> </div> This might generate the following Turtle: @prefix md: <http://www.w3.org/ns/md#> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix rdfa: <http://www.w3.org/ns/rdfa#> . @prefix schema: <http://schema.org/> . <> md:item [ a schema:MusicPlaylist; schema:name "Classic Rock Playlist"; schema:byArtist ("Lynard Skynard" "AC/DC"); schema:numTracks "2"; schema:tracks _:track1, _:track2, (_:track1 _:track2) ]; rdfa:usesVocabulary schema: . _:track1 a schema:MusicRecording; schema:byArtist ("Lynard Skynard"); schema:name "Sweet Home Alabama"; schema:url <sweet-home-alabama> . _:track2 a schema:MusicRecording; schema:byArtist ("AC/DC"); schema:name "Shook you all Night Long"; schema:url <shook-you-all-night-long> . By providing both _:track1 and _:track2 as object values of the playlist along with an RDF Collection containing the ordered values, the data may generated property URIs can be queried via a simple query using the playlist subject, or split as an ordered collection. follows:

Example 6
<rdf:Description xmlns:base="http://example/author#"
               rdf:type="http://microformats.org/profile/hcard">
<base:bar>
  <rdf:Description>
    <base:baz>Baz</base:baz>
  </rdf:Description>
</base:bar>
</rdf:Description>

3.3 3.2 Value Typing

This section is non-normative.

In microdata, all values are strings. In RDF, values may be resources or may be typed with an appropriate datatype.

In some cases, the type of a microdata value can be determined from the element on which it is specified. In particular:

4. Vocabulary Expansion

Microdata requires that all values of itemtype come from the same vocabulary. This is required as itemprop values are resolved relative to that vocabulary. However, it is often useful to define an item to have types from multiple different vocabularies.

Vocabulary expansion uses simple rules to generate additional triples based on rules and property relationships described in the registry . Within the registry , a property definition may have either equivalentProperty or subPropertyOf keys having a IRI value (or array of IRI values) of the associated property. Such an entry causes the processor to generate triples associating the source property IRI with the target property IRI using either http://www.w3.org/2000/01/rdf-schema#subPropertyOf rdf:subPropertyOf or http://www.w3.org/2002/07/owl#equivalentProperty owl:equivalentProperty predicates.

For example, the registry definition for the additionalType property within schema.org, defines additionalType to have an rdfs:subPropertyOf relationship with http://www.w3.org/1999/02/22-rdf-syntax-ns#type rdf:type .

{ "http://schema.org/": { "properties": { } } <div itemscope itemtype="http://schema.org/Person"> <link itemprop="additionalType" href="http://xmlns.com/foaf/0.1/Person"/> <a itemprop="email http://xmlns.com/foaf/0.1/mbox" href="mailto:mail@gmail.com"> mail@gmail.com </a>
Example 7
<div itemscope itemtype="http://schema.org/Person">
  <link itemprop="additionalType" href="http://xmlns.com/foaf/0.1/Person"/>
  <a itemprop="email http://xmlns.com/foaf/0.1/mbox" href="mailto:mail@gmail.com">
    mail@gmail.com
  </a>

</div>

The previous example, indicates a registry rule, which causes the processor to emit an extra triple when first seeing the additionalProperty itemprop :

@prefix foaf: <http://xmlns.com/foaf/0.1/> . @prefix md: <http://www.w3.org/ns/md#> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix rdfa: <http://www.w3.org/ns/rdfa#> . @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . @prefix schema: <http://schema.org/> . <> md:item ( [ a schema:Person; schema:additionalType foaf:Person; schema:email <mailto:mail@gmail.com>; foaf:mbox <mailto:mail@gmail.com>]); rdfa:usesVocabulary schema: . schema:additionalType rdfs:subPropertyOf rdf:type
Example 8
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfa: <http://www.w3.org/ns/rdfa#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix schema: <http://schema.org/> .

[ a schema:Person;
  schema:additionalType foaf:Person;
  schema:email <mailto:mail@gmail.com>;
  foaf:mbox <mailto:mail@gmail.com>
]

.

After performing vocabulary expansion, an additional rdf:type triple is generated:

@prefix foaf: <http://xmlns.com/foaf/0.1/> . @prefix md: <http://www.w3.org/ns/md#> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix rdfa: <http://www.w3.org/ns/rdfa#> . @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . @prefix schema: <http://schema.org/> . <> md:item ( [ a schema:Person, foaf:Person; schema:additionalType foaf:Person; schema:email <mailto:mail@gmail.com>; foaf:mbox <mailto:mail@gmail.com>]); rdfa:usesVocabulary schema: . schema:additionalType rdfs:subPropertyOf rdf:type
Example 9
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfa: <http://www.w3.org/ns/rdfa#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix schema: <http://schema.org/> .

<> rdfa:usesVocabulary schema: .
[ a schema:Person, foaf:Person;
  schema:additionalType foaf:Person;
  schema:email <mailto:mail@gmail.com>;
  foaf:mbox <mailto:mail@gmail.com>
]

.
4.1 Vocabulary Entailment Formally, and for the purpose of vocabulary processing, microdata uses a very restricted subset of the OWL2 vocabulary and is based on the RDF-Based Semantics of OWL2 [ OWL2-RDF-BASED-SEMANTICS ]. Vocabulary Entailment uses the following terms: rdfs:subPropertyOf owl:equivalentProperty Vocabulary Entailment considers only the entailment on individuals (i.e., not on the relationships that can be deduced on the properties or the classes themselves.)
Note

While the formal definition of the Entailment refers to the general OWL 2 Semantics, practical implementations may rely on a subset of the OWL 2 RL Profile’s entailment expressed in rules ( section 4.3 of [ OWL2-PROFILES ]). The relevant rules are, using the rule identifications in section 4.3 of [ OWL2-PROFILES ]): prp-spo1 , owl:equivalentProperty rule is more powerfull than prp-eqp1 rdfs:subPropertyOf , and prp-eqp2 . [ RDFA-CORE ] implements a more complete form of vocabulary entailement, including retrieving in that if any equivalent property matches, then the vocabulary URI to find additional class and source property expansion definitions, as described in RDFa Vocabulary Entailment . Microdata implementations may use RDFa Vocabulary Entailment as an alternative to implementing would also cause a separate entailment algorithm. To allow [ RDFA-CORE ] processors triple to be used for microdata vocabulary expansion, microdata acts as generated. For example, if there is an implicit the registry stated that @vocab name RDFa attribute set was equivalent to rdfs:label , than any use of name in a detected vocabulary by emitting itemprop would cause a triple using the rdfa:usesVocabulary rdfs:label predicate. Note The entailment described in this section is the minimum useful level for microdata. Processors may, of course, choose to follow more powerful entailment regimes, e.g., include full RDFS [ RDF-MT ] or OWL2 [ OWL2-OVERVIEW ] entailments. Using those entailments applications may perform datatype validation by checking be emitted, as with rdfs:range rdfs:subPropertyOf . However, logically, any use of label where the current voabulary were rdfs: could also cause a triple using schema:name to be emitted. To simplify processing, this specification requires that all values of a property, or use owl:equivalentProperty registry entry have their own rules with those values as keys within the advanced facilities offered by, e.g., OWL2’s property chains to interlink vocabularies further. section of their respective vocabularies.

4.2 5. Vocabulary Expansion Control of Microdata Processors

Conforming processors The external registry may be controlled by the registry option passed to the microdata processor. If specified, the registry must be loaded from the location indicated as the option value, Otherwise, the processor MUST perform load the basic vocabulary expansion. default registry from http://www.w3.org/ns/md .

If vocabulary expansion Setting registry is performed by the microdata processor in a processor-specific way.

When accessed as a web service using [ RDFA-CORE ] vocabulary expansion, and the HTTP GET, POST or similar action, processors SHOULD use vocab_expansion registry query parameter. Acceptable values for registry option is passed to the microdata processor, a URI-encoded URL. Web service processors SHOULD return the full resulting RDF graph using a requested format specified by HTTP Content Negotiation for an acceptable content type. Web service processors MUST support [ RDFA-CORE N-TRIPLES ] expansion must also be performed. ].

5. 6. Algorithm

Transformation of Microdata to RDF makes use of general processing rules described in [ MICRODATA ] for the treatment of item s. items .

5.1 6.1 Algorithm Terms

absolute URL
The term absolute URL is defined in [ HTML5 ].
blank node
A blank node is a node in a graph that is neither a URI reference nor a literal . Item s without a global identifier have a blank node allocated to them. (See [ RDF-CONCEPTS RDF11-CONCEPTS ]).
canonicalized fragment
The term canonicalized fragment is defined in [ URL ]. This involves transforming elements added to URLs to ensure that the result remains a valid URL. Non-Unicode characters, and characters less than U+0020 SPACE character (" ") are subject to percent escaping.
document base
The base address of the document being processed, as defined in Resolving URLs in [ HTML5 ].
evaluation context
A data structure including the following elements:
memory
a mapping of items to subjects, initially empty;
current name an absolute URL for the in-scope name , used for generating URIs for properties of items without an item type ; Note current name is required for the contextual property URI generation scheme. Without this scheme, this evaluation context component would not be required. current type
an absolute URL for the current type , used when an item does not contain an item type ;
current vocabulary
an absolute URL for the current vocabulary , from the registry .
item
An item is described by an element containing an itemscope attribute. The list of top-level microdata items may be retrieved using the Microdata DOM API document.getItems method.
item properties
The mechanism for finding the properties of an item The list of item properties items may be retrieved using the Microdata DOM API element.properties attribute.
fragment-escape The term fragment-escape is defined in [ HTML5 ]. This involves transforming elements added to URLs to ensure that the result remains a valid URL. The following characters are subject to percent escaping: U+0022 QUOTATION MARK character (") U+0023 NUMBER SIGN character (#) U+0025 PERCENT SIGN character (%) U+003C LESS-THAN SIGN character (<) U+003E GREATER-THAN SIGN character (>) U+005B LEFT SQUARE BRACKET character ([) U+005C REVERSE SOLIDUS character (\) U+005D RIGHT SQUARE BRACKET character (]) U+005E CIRCUMFLEX ACCENT character (^) U+007B LEFT CURLY BRACKET character ({) U+007C VERTICAL LINE character (|) U+007D RIGHT CURLY BRACKET character (}) global identifier
The value of an item 's itemid attribute, if it has one. one, resolved relative to the element on which the attribute is specified. (See Items itemscope in [ MICRODATA ]).
literal
Literals are values such as strings and dates, including dates. These include typed literal literals , language-tagged strings s and plain literal s. (See simple literals , as defined in [ RDF-CONCEPTS RDF11-CONCEPTS ]). ].
property
Each name identifies a property of an item . An item may have multiple elements sharing the same name , creating a multi-valued property .
property names
The tokens of an element's itemprop attribute. Each token is a name . (See Names: the itemprop attribute property names in [ MICRODATA ]).
property value
The property value of a name-value pair added by an element with an itemprop attribute depends on the element.
If the element has no itemprop attribute
The value is null and no triple should be generated.
If the element creates an item (by having an itemscope attribute)
The value is the URI reference or blank node returned from generate the triples for that item .
If the element is a URL property element ( a , area , audio , embed , iframe , img , link , object , source , track or video )
The value is a URI reference created from element.itemValue . (See relevant attribute descriptions in [ HTML5 ]).
If the element is a meter or data element.
The value is a literal made from element.itemValue .
If the value is a valid integer having the lexical form of xsd:integer [ XMLSCHEMA11-2 ]
The value is a typed literal composed of the value and http://www.w3.org/2001/XMLSchema#integer .
If the value is a valid float number having the lexical form of xsd:double [ XMLSCHEMA11-2 ]
The value is a typed literal composed of the value and http://www.w3.org/2001/XMLSchema#double .
Otherwise
The value is a simple literal .
If the element is a meta element with a @content attribute.
If the element has a non-empty language , the value is a language-tagged string created from the value of the @content attribute with language information set from the language of the property element. Otherwise, the value is a simple literal created from the value of the @content attribute.
If the element is a time element.
The value is a literal made from element.itemValue .
If the value is a valid date string having the lexical form of xsd:date [ RDF-SCHEMA XMLSCHEMA11-2 ].
The value is a typed literal composed of the value and http://www.w3.org/2001/XMLSchema#date .
If the value is a valid time string having the lexical form of xsd:time [ RDF-SCHEMA XMLSCHEMA11-2 ].
The value is a typed literal composed of the value and http://www.w3.org/2001/XMLSchema#time .
If the value is a valid local date and time string or valid global date and time string having the lexical form of xsd:dateTime [ RDF-SCHEMA XMLSCHEMA11-2 ].
The value is a typed literal composed of the value and http://www.w3.org/2001/XMLSchema#dateTime .
If the value is a valid month string having the lexical form of xsd:gYearMonth [ RDF-SCHEMA XMLSCHEMA11-2 ].
The value is a typed literal composed of the value and http://www.w3.org/2001/XMLSchema#gYearMonth .
If the value is a valid non-negative integer having the lexical form of xsd:gYear [ RDF-SCHEMA XMLSCHEMA11-2 ].
The value is a typed literal composed of the value and http://www.w3.org/2001/XMLSchema#gYear .
If the value has is a valid duration string having the lexical form of xsd:duration [ RDF-SCHEMA XMLSCHEMA11-2 ].
The value is a typed literal composed of the value and http://www.w3.org/2001/XMLSchema#duration . Note The referenced version of [ HTML5 ] does not include a duration data type, but it is in the Editor's Draft and is expected to be included in a forthcoming update to the Working Draft
Otherwise
The If the element has a non-empty language , the value is a plain literal language-tagged string created from the value with language information set from the language of the property element. Otherwise, the value is a simple literal created from the value.
Note

The HTML valid yearless date string is similar to xsd:gMonthDay , but the lexical forms differ, so it is not included in this conversion.

See The time element in [ HTML5 ].

Otherwise
The If the element has a non-empty language , the value is a plain literal language-tagged string created from the value with language information set from the language of the property element. Otherwise, the value is a simple literal created from the value.

See The lang and xml:lang attributes in [ HTML5 ] for determining the language of a node.

top-level item
An item which does not contain an itemprop attribute. Available through the Microdata DOM API as document.getItems . (See Associating names with items top-level microdata item in [ MICRODATA ]).
URI reference
URI references are suitable to be used in subject , predicate or object positions within an RDF triple, as opposed to a literal value that may contain a string representation of a URI. (See [ RDF-CONCEPTS RDF11-CONCEPTS ]).
Issue

The HTML5/microdata content model for @href , @src , @data , itemtype and itemprop and itemid is that of a URL, not a URI or IRI.

A proposed mechanism for specifying the range of property value values s to be URI reference or IRI could allow these to be specified as subject or object using a @content attribute.

vocabulary
A vocabulary is a collection of URIs, suitable for use as an itemtype or itemprop value, that share a common URI prefix . That prefix is the vocabulary URI. A vocabulary URI is not allowed to be a prefix of another vocabulary URI.
Note
This definition differs from the language in the HTML spec and is just for the purpose of this document. In HTML, a vocabulary is a specification, and doesn't have a URI. In our view, if one specification defines ten itemtype s, then these could be treated as one vocabulary or as ten distinct vocabularies; it is entirely up to the vocabulary creator.

5.2 6.2 RDF Conversion Algorithm

A HTML document containing microdata may MAY be converted to any other RDF-compatible document format using the algorithm specified in this section.

A conforming microdata processor implementing RDF conversion must MUST implement a processing algorithm that results in the equivalent triples to those that the following algorithm generates:

Set item list to an empty list.
  1. For each element that is also a top-level item run the following algorithm: , Generate the triples for an item that item , using the evaluation context . Let result be the ( URI reference or blank node ) subject returned. Append result to item list . Generate an RDF Collection list from the ordered list of values. Set value to the value returned from generate an RDF Collection . Generate the following triple: subject document base predicate http://www.w3.org/ns/md#item object value Perform Vocabulary Entailment .

5.3 6.3 Generate the triples

When the user agent is to Generate triples for an item item , given evaluation context , it must run the following steps:

Note

This algorithm has undergone substantial change from the original microdata specification [ MICRODATA ].

  1. If there is an entry for item in memory , then let subject be the subject of that entry. Otherwise, if item has a global identifier and that global identifier is an absolute URL , let subject be that global identifier . Otherwise, let subject be a new blank node .
  2. Add a mapping from item to subject in memory
  3. For each type returned from element.itemType of the element defining the item .
    1. If type is an absolute URL , generate the following triple:
      subject
      subject
      predicate
      http://www.w3.org/1999/02/22-rdf-syntax-ns#type
      object
      type (as a URI reference )
  4. Set type to the first value returned from element.itemType of the element defining the item .
  5. If type is an absolute URL , set current name in evaluation context to null. Otherwise, set type to current type from evaluation context if not empty.
  6. If the registry contains a URI prefix that is a character for character match of type up to the length of the URI prefix , set vocab as that URI prefix and generate the following triple: subject document base predicate http://www.w3.org/ns/rdfa#usesVocabulary object vocab (as a URI reference ) .
  7. Otherwise, if type is not empty, construct vocab by removing everything following the last SOLIDUS U+002F ("/") or NUMBER SIGN U+0023 ("#") from the path component of type .
  8. Update evaluation context setting current vocabulary to vocab .
  9. Set property list to an empty array mapping properties to one or more value s as established below.
  10. For each element element that has one or more property names and is one of the properties of the item item , in the order those elements are given by the algorithm that returns the properties of the item , run the following substep:
    1. For each name in the element's property names , run the following substeps:
      1. Let context be a copy of evaluation context with current type set to type .
      2. Let predicate be the result of generate predicate URI using context and name . Update context by setting current name to predicate .
      3. Let value be the property value of element .
      4. If value is an item , then generate the triples for value using context . Replace value by the subject returned from those steps.
      5. Add value to Generate the following triple:
        subject
        property list subject for
        predicate . For each
        predicate in
        object
        property list : value Generate property values
      6. If an entry exists in the registry for subject , predicate name and in the list of values vocabulary associated with predicate vocab from having the key subPropertyOf or equivalentProperty , for each such value property list equiv , generate the following triple:
        subject
        subject as
        predicate
        values . equiv
        object
        value
  11. Return subject

5.4 6.4 Generate Predicate URI

Predicate URI generation makes use of current type , current name , and current vocabulary from an evaluation context context along with name .

  1. If name is an absolute URL , return name as a URI reference .
  2. If current type from context is null, there can be no current vocabulary . Return the URI reference that is the document base with its fragment set to the fragment-escape canonicalized fragment d value of name .
    Note
    This rule is intended to allow for a the case where no type is set, and therefore there is no vocabulary from which to extract rules. For example, if there is a document base of http://example.org/doc and an itemprop of 'title', a URI will be constructed to be http://example.org/doc#title .
  3. Otherwise, if current vocabulary from context is not null and registry has an entry for current vocabulary having a propertyURI entry that is not null, set that as scheme . Otherwise, set scheme to vocabulary .
  4. If scheme is vocabulary set Set expandedURI to the URI reference constructed by appending the fragment-escape canonicalized fragment d value of name to current vocabulary , separated by a U+0023 NUMBER SIGN character (#) ("#") unless the current vocabulary ends with either a U+0023 NUMBER SIGN character (#) ("#") or SOLIDUS U+002F (/). ("/").
  5. Otherwise, if scheme is contextual , set
  6. Return expandedURI to the URI reference .

A. Reverse itemprop constructed as follows: Let

s This section is non-normative. be current name

The WebSchemas community has proposed from context . If http://www.w3.org/ns/md?type= is a prefix of s , return the concatenation use of s , a U+002E FULL STOP character (.) and the fragment-escape new Microdata attribute: itemprop-reverse . Although not present in [ MICRODATA d value ] at this time, the attribute can be very useful in many markup examples where items are related using the reverse of name . Otherwise, return a common property; this saves creating new properties which exist solely for the concatenation purpose of http://www.w3.org/ns/md?type= , describing such reverse relationships. Evidence for the fragment-escape d value utility of current type , such a feature can be seen in the string RDFa &prop= , @rev attribute [ RDFA-CORE ] and the fragment-escape JSON-LD @reverse property d value of name . If the registry [ JSON-LD entry for propertyURI ].

Note

See issue 5 has an equivalentProperty key, generate for further reference.

This feature adds the following triple using the value of that key: attribute:

subject expandedURI itemprop-reverse predicate
http://www.w3.org/2002/07/owl#equivalentProperty object
value If the value is An attribute used to identify one or more names of an array, generate items reversing the sense of itemprop . An itemprop-reverse contains a triple for each value space separated list of that array. If the registry names entry for propertyURI which may either by absolute URLs has an subPropertyOf key, generate the following triple using or terms associated with the value type of that key: subject expandedURI the item as defined by the referencing item 's item type .

The Algorithm is extended accordingly:

A.1 Algorithm Terms

predicate http://www.w3.org/2000/01/rdf-schema#subPropertyOf reverse properties object
value If
The mechanism for finding the value reverse properties of an item The list of reverse properties is the result of transforming each space-separated-value of an array, generate item's itemprop-reverse to a triple for each value URL as defined in Property URI Generation .
reverse property names
The tokens of that array. Return expandedURI . an element's itemprop-reverse attribute. Each token is a name .

5.5 A.2 Generate Property Values the triples

Property value serialization makes use of subject , predicate and values . The Triples generation algorithm is extended with the following step to take place immediately after Step 9 :

  1. If the registry contains a URI prefix For each element element that has one or more reverse property names and is a character for character match one of predicate up to the length reverse properties of the URI prefix, set vocab as that URI prefix. Otherwise set item vocab to null. item , run the following substep:
    1. If vocab is not null and registry has an entry for For each vocab name that is a JSON Object, let in the element's reverse property names , run the following substeps:
      1. Let registry object context be that value. Otherwise a copy of evaluation context with current type set registry object to null. If registry object type is not null and registry object contains key properties current vocabulary which has a JSON Object value, let properties be that value. Otherwise, set properties to null. vocab .
      2. If properties is not null, and Let properties predicate contains a key, which after be the result of Generate Predicate generate predicate URI expansion has a value which is a JSON Object, let property override be that value. Otherwise, set property override to null. If using property override context contains the key multipleValues , set that as and method name .
      3. Otherwise, if Let registry object value con contains be the key multipleValues , set that as property value of method element .
      4. Otherwise, set method to unordered . If method is unordered , for each value in values , is an item , then generate the following triple: subject triples for subject value predicate using predicate object context . Replace value by the subject returned from those steps.
      5. Otherwise, if method value is list : Set a literal ignore the value and continue to the value returned from generate next name ; it is an RDF Collection error for the value of itemprop-reverse to be a literal .
      6. Generate the following triple:
        subject
        subject value
        predicate
        predicate
        object
        value subject
5.6 Generate RDF Collection

An RDF Collection is a mechanism for defining ordered sequences of objects in RDF (See RDF Collections in [ RDF-SCHEMA ]). As the RDF data-model is that Simple use of an unordered graph, a linking method using properties rdf:first and rdf:next is required to be able to specify a particular order. In the microdata to RDF mapping, RDF Collection s are used when an item has more than one value associated with a given property to ensure that the original document order is maintained. The following procedure should be used to generate triples when an item property has more than one value (contained in list ): itemprop-reverse :

Create a new array array containing a blank node for every value in list . For each pair of bnode from array and value from list the following triple is generated: subject bnode predicate http://www.w3.org/1999/02/22-rdf-syntax-ns#first object value
Example 10
<div  itemscope itemtype="http://schema.org/Person">
  <span itemprop="name">William Shakespeare</span>
  <link itemprop-reverse="creator" href="http://www.freebase.com/m/0yq9mqd">
</div>
For each bnode

Results in array the following triple is generated: subject bnode predicate http://www.w3.org/1999/02/22-rdf-syntax-ns#rest Turtle:

Example 11
@prefix schema: <http://schema.org/> .

<http://www.freebase.com/m/0yq9mqd> schema:creator [
  a schema:Person;
  schema:name "William Shakespeare"
]
.
object next bnode in array or, if that does not exist, http://www.w3.org/1999/02/22-rdf-syntax-ns#nil Return the first blank node from array .

A. B. Testing

This section is non-normative.

A test suite [ MICRODATA-RDF-TESTS ] under development to help processor developers verify conformance to this specification.

B. C. Markup Examples

This section is non-normative.

The microdata example below expresses book information as an FRBR Work item.

<dl itemscope itemtype="http://purl.org/vocab/frbr/core#Work" itemid="http://books.example.com/works/45U8QJGZSQKDH8N" lang="en"> <dt>Title</dt> <dd><cite itemprop="http://purl.org/dc/terms/title">Just a Geek</cite></dd> <dt>By</dt> <dd><span itemprop="http://purl.org/dc/terms/creator">Wil Wheaton</span></dd> <dt>Format</dt> <dd itemprop="http://purl.org/vocab/frbr/core#realization" itemscope itemtype="http://purl.org/vocab/frbr/core#Expression" itemid="http://books.example.com/products/9780596007683.BOOK"> <link itemprop="http://purl.org/dc/terms/type" href="http://books.example.com/product-types/BOOK"> Print </dd> <dd itemprop="http://purl.org/vocab/frbr/core#realization" itemscope itemtype="http://purl.org/vocab/frbr/core#Expression" itemid="http://books.example.com/products/9780596802189.EBOOK"> <link itemprop="http://purl.org/dc/terms/type" href="http://books.example.com/product-types/EBOOK"> Ebook </dd>
Example 12
<dl itemscope
    itemtype="http://purl.org/vocab/frbr/core#Work"
    itemid="http://books.example.com/works/45U8QJGZSQKDH8N"
    lang="en">
 <dt>Title</dt>
 <dd><cite itemprop="http://purl.org/dc/terms/title">Just a Geek</cite></dd>
 <dt>By</dt>
 <dd><span itemprop="http://purl.org/dc/terms/creator">Wil Wheaton</span></dd>
 <dt>Format</dt>
 <dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://books.example.com/products/9780596007683.BOOK">
  <link itemprop="http://purl.org/dc/terms/type" href="http://books.example.com/product-types/BOOK">
  Print
 </dd>
 <dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://books.example.com/products/9780596802189.EBOOK">
  <link itemprop="http://purl.org/dc/terms/type" href="http://books.example.com/product-types/EBOOK">
  Ebook
 </dd>

</dl>

Assuming that registry contains a an entry for http://purl.org/vocab/frbr/core# with propertyURI set to vocabulary , this is equivalent to the following Turtle:

@prefix dc: <http://purl.org/dc/terms/> . @prefix md: <http://www.w3.org/ns/md#> . @prefix frbr: <http://purl.org/vocab/frbr/core#> . @prefix rdfa: <http://www.w3.org/ns/rdfa#> . <> md:item (<http://books.example.com/works/45U8QJGZSQKDH8N>) ; rdfa:usesVocabulary frbr: . <http://books.example.com/works/45U8QJGZSQKDH8N> a frbr:Work ; dc:creator "Wil Wheaton"@en ; dc:title "Just a Geek"@en ; frbr:realization <http://books.example.com/products/9780596007683.BOOK>, <http://books.example.com/products/9780596802189.EBOOK> . <http://books.example.com/products/9780596007683.BOOK> a frbr:Expression ; dc:type <http://books.example.com/product-types/BOOK> . <http://books.example.com/products/9780596802189.EBOOK> a frbr:Expression ;
Example 13
@prefix dc: <http://purl.org/dc/terms/> .
@prefix frbr: <http://purl.org/vocab/frbr/core#> .
@prefix rdfa: <http://www.w3.org/ns/rdfa#> .

<> rdfa:usesVocabulary frbr: .

<http://books.example.com/works/45U8QJGZSQKDH8N> a frbr:Work ;
  dc:creator "Wil Wheaton"@en ;
  dc:title "Just a Geek"@en ;
  frbr:realization <http://books.example.com/products/9780596007683.BOOK>,
    <http://books.example.com/products/9780596802189.EBOOK> .

<http://books.example.com/products/9780596007683.BOOK> a frbr:Expression ;
  dc:type <http://books.example.com/product-types/BOOK> .

<http://books.example.com/products/9780596802189.EBOOK> a frbr:Expression ;

dc:type
<http://books.example.com/product-types/EBOOK>
.

The following snippet of HTML has microdata for two people with the same address. This illustrates two item items s referencing a third item, and how only a single RDF resource definition is created for that third item.

<p> Both <span itemscope itemtype="http://microformats.org/profile/hcard" itemref="home"> <span itemprop="fn" ><span itemprop="n" itemscope ><span itemprop="given-name">Princeton</span></span></span> </span> and <span itemscope itemtype="http://microformats.org/profile/hcard" itemref="home"> <span itemprop="fn" ><span itemprop="n" itemscope ><span itemprop="given-name">Trekkie</span></span></span> </span> live at <span id="home" itemprop="adr" itemscope> <span itemprop="street-address">Avenue Q</span>. </span>
Example 14
<p>
 Both
 <span itemscope itemtype="http://microformats.org/profile/hcard" itemref="home">
   <span itemprop="fn"
       ><span itemprop="n" itemscope
       ><span itemprop="given-name">Princeton</span></span></span>
  </span>
 and
 <span itemscope itemtype="http://microformats.org/profile/hcard" itemref="home">
   <span itemprop="fn"
     ><span itemprop="n" itemscope
       ><span itemprop="given-name">Trekkie</span></span></span>
  </span>
 live at
 <span id="home" itemprop="adr" itemscope>
   <span itemprop="street-address">Avenue Q</span>.
 </span>

</p>

Assuming that registry contains a an entry for http://microformats.org/profile/hcard with propertyURI set to vocabulary , it generates these triples expressed in Turtle:

@prefix md: <http://www.w3.org/ns/md#> . @prefix hcard: <http://microformats.org/profile/hcard#> . @prefix rdfa: <http://www.w3.org/ns/rdfa#> . <> md:item ( [ a <http://microformats.org/profile/hcard>; hcard:fn "Princeton"; hcard:n [ hcard:given-name "Princeton" ]; hcard:adr _:a ] [ a <http://microformats.org/profile/hcard>; hcard:fn "Trekkie"; hcard:n [ hcard:given-name "Trekkie" ]; hcard:adr _:a ]) ; rdfa:usesVocabulary <http://microformats.org/profile/hcard> .
Example 15
@prefix hcard: <http://microformats.org/profile/hcard#> .
@prefix rdfa: <http://www.w3.org/ns/rdfa#> .

[ a <http://microformats.org/profile/hcard>;
  hcard:fn "Princeton";
  hcard:n [ hcard:given-name "Princeton" ];
  hcard:adr _:a
] .
[ a <http://microformats.org/profile/hcard>;
  hcard:fn "Trekkie";
  hcard:n [ hcard:given-name "Trekkie" ];
  hcard:adr _:a
] .


_:a
hcard:street-address
"Avenue
Q"
.

The following snippet of HTML has microdata for a playlist, playlist and illustrates overriding a property to place elements in an RDF Collection. This also illustrates the use of the schema:additionalType property to relate recordings to the Music Ontology :

<div itemscope itemtype="http://schema.org/MusicPlaylist"> <span itemprop="name">Classic Rock Playlist</span> <meta itemprop="numTracks" content="2"/> <p>Including works by <span itemprop="byArtist">Lynard Skynard</span> and <span itemprop="byArtist">AC/DC</span></p>. <div itemprop="tracks" itemscope itemtype="http://schema.org/MusicRecording"> <link itemprop="additionalType" href="http://purl.org/ontology/mo/MusicalManifestation"/> 1.<span itemprop="name">Sweet Home Alabama</span> - <span itemprop="byArtist">Lynard Skynard</span> <link href="sweet-home-alabama" itemprop="url" /> </div> <div itemprop="tracks" itemscope itemtype="http://schema.org/MusicRecording"> <link itemprop="additionalType" href="http://purl.org/ontology/mo/MusicalManifestation"/> 2.<span itemprop="name">Shook you all Night Long</span> - <span itemprop="byArtist">AC/DC</span> <link href="shook-you-all-night-long" itemprop="url" /> </div>
Example 16
<div itemscope itemtype="http://schema.org/MusicPlaylist">
  <span itemprop="name">Classic Rock Playlist</span>
  <meta itemprop="numTracks" content="2"/>
  <p>Including works by
    <span itemprop="byArtist">Lynard Skynard</span> and
    <span itemprop="byArtist">AC/DC</span></p>.

  <div itemprop="tracks" itemscope itemtype="http://schema.org/MusicRecording">
    <link itemprop="additionalType" href="http://purl.org/ontology/mo/MusicalManifestation"/>
    1.<span itemprop="name">Sweet Home Alabama</span> -
    <span itemprop="byArtist">Lynard Skynard</span>
    <link href="sweet-home-alabama" itemprop="url" />
   </div>

  <div itemprop="tracks" itemscope itemtype="http://schema.org/MusicRecording">
    <link itemprop="additionalType" href="http://purl.org/ontology/mo/MusicalManifestation"/>
    2.<span itemprop="name">Shook you all Night Long</span> -
    <span itemprop="byArtist">AC/DC</span>
    <link href="shook-you-all-night-long" itemprop="url" />
  </div>

</div>

Assuming that registry contains a an entry for http://schema.org/ with propertyURI set to vocabulary , multipleValues set to unordered with the properties track and byArtist having multipleValues set to list , it generates these triples expressed in Turtle:

@prefix md: <http://www.w3.org/ns/md#> . @prefix mo: <http://purl.org/ontology/mo/> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix rdfa: <http://www.w3.org/ns/rdfa#> . @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . @prefix schema: <http://schema.org/> . <> md:item ([ a schema:MusicPlaylist; schema:name "Classic Rock Playlist"; schema:byArtist ("Lynard Skynard" "AC/DC"); schema:numTracks "2"; schema:tracks ( [ a schema:MusicRecording, mo:MusicalManifestation; schema:additionalType mo:MusicalManifestation; schema:byArtist ("Lynard Skynard"); schema:name "Sweet Home Alabama"; schema:url <sweet-home-alabama>] [ a schema:MusicRecording, mo:MusicalManifestation; schema:additionalType mo:MusicalManifestation; schema:byArtist ("AC/DC");; schema:name "Shook you all Night Long"; schema:url <shook-you-all-night-long>] )]); rdfa:usesVocabulary schema: . schema:additionalType rdfs:subPropertyOf rdf:type
Example 17
@prefix mo: <http://purl.org/ontology/mo/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfa: <http://www.w3.org/ns/rdfa#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix schema: <http://schema.org/> .

[ a schema:MusicPlaylist;
  schema:name "Classic Rock Playlist";
  schema:byArtist "Lynard Skynard" "AC/DC";
  schema:numTracks "2";
  schema:tracks [
    a schema:MusicRecording, mo:MusicalManifestation;
    schema:additionalType mo:MusicalManifestation;
    schema:byArtist "Lynard Skynard";
    schema:name "Sweet Home Alabama";
    schema:url <sweet-home-alabama>
  ], [
    a schema:MusicRecording, mo:MusicalManifestation;
    schema:additionalType mo:MusicalManifestation;
    schema:byArtist "AC/DC";;
    schema:name "Shook you all Night Long";
    schema:url <shook-you-all-night-long>
  ]
]

.

C. D. Example Default registry

This section is non-normative.

The following is an example the default registry in JSON format. format, as of the time of publication.

{ "http://schema.org/": { "propertyURI": "vocabulary", "multipleValues": "unordered", "properties": { "additionalType": {"subPropertyOf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "blogPosts": {"multipleValues": "list"}, "blogPosts": {"multipleValues": "list"}, "breadcrumb": {"multipleValues": "list"}, "byArtist": {"multipleValues": "list"}, "creator": {"multipleValues": "list"}, "episode": {"multipleValues": "list"}, "episodes": {"multipleValues": "list"}, "event": {"multipleValues": "list"}, "events": {"multipleValues": "list"}, "founder": {"multipleValues": "list"}, "founders": {"multipleValues": "list"}, "itemListElement": {"multipleValues": "list"}, "musicGroupMember": {"multipleValues": "list"}, "performerIn": {"multipleValues": "list"}, "actor": {"multipleValues": "list"}, "actors": {"multipleValues": "list"}, "performer": {"multipleValues": "list"}, "performers": {"multipleValues": "list"}, "producer": {"multipleValues": "list"}, "recipeInstructions": {"multipleValues": "list"}, "season": {"multipleValues": "list"}, "seasons": {"multipleValues": "list"}, "subEvent": {"multipleValues": "list"}, "subEvents": {"multipleValues": "list"}, "track": {"multipleValues": "list"}, "tracks": {"multipleValues": "list"} } }, "http://microformats.org/profile/hcard": { "propertyURI": "vocabulary", "multipleValues": "unordered" }, "http://microformats.org/profile/hcalendar#": { "propertyURI": "vocabulary", "multipleValues": "unordered", "properties": { "categories": {"multipleValues": "list"} } }
Example 18
{
  "http://schema.org/": {
    "properties": {
      "additionalType": {"subPropertyOf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}
    }
  },
  "http://microformats.org/profile/hcard": {}

}

D. E. Acknowledgements

This section is non-normative.

Thanks to Richard Cyganiak for property URI and vocabulary terminology and the general excellent consideration of practical problems in generating RDF from microdata.

E. F. References

E.1 F.1 Normative references

[HTML5]
Ian Hickson; David Hyatt. Robin Berjon; Steve Faulkner; Travis Leithead; Erika Doyle Navara; Edward O'Connor; Silvia Pfeiffer. HTML5. HTML5 29 March 2012. . 28 October 2014. W3C Working Draft. (Work in progress.) Recommendation. URL: http://www.w3.org/TR/html5 http://www.w3.org/TR/html5/
[MICRODATA]
HTML Microdata
Ian Hickson Editor. W3C Working Draft. (Work in progress). 29 March 2012. This edition of the HTML Microdata specification is http://www.w3.org/TR/2012/WD-microdata-20120329/. The Hickson. latest edition of HTML Microdata is available at http://www.w3.org/TR/microdata/ [OWL2-OVERVIEW] W3C OWL Working Group. OWL 2 Web Ontology Language: Overview. HTML Microdata 27 . 29 October 2009. 2013. W3C Recommendation. Note. URL: http://www.w3.org/TR/2009/REC-owl2-overview-20091027/ http://www.w3.org/TR/microdata/
[OWL2-PROFILES]
[N-TRIPLES]
Boris Motik; Bernardo Cuenca Grau; Ian Horrocks; Zhe Wu; Achille Fokoue; Carsten Lutz.
Gavin Carothers; Andy Seaborne. OWL 2 Web Ontology Language:Profiles. RDF 1.1 N-Triples 27 October 2009. . 25 February 2014. W3C Recommendation. URL: http://www.w3.org/TR/2009/REC-owl2-profiles-20091027/ http://www.w3.org/TR/n-triples/
[OWL2-RDF-BASED-SEMANTICS]
[RDF11-CONCEPTS]
Michael Schneider.
Richard Cyganiak; David Wood; Markus Lanthaler. OWL 2 Web Ontology Language:RDF-Based Semantics. RDF 1.1 Concepts and Abstract Syntax 27 October 2009. . 25 February 2014. W3C Recommendation. URL: http://www.w3.org/TR/2009/REC-owl2-rdf-based-semantics-20091027/ http://www.w3.org/TR/rdf11-concepts/
[RDF-CONCEPTS]
[RFC3986]
Graham Klyne; Jeremy J. Carroll.
T. Berners-Lee; R. Fielding; L. Masinter. Uniform Resource Description Framework (RDF): Concepts and Abstract Syntax. Identifier (URI): Generic Syntax 10 February 2004. W3C Recommendation. . January 2005. Internet Standard. URL: http://www.w3.org/TR/2004/REC-rdf-concepts-20040210 https://tools.ietf.org/html/rfc3986
[RDF-MT]
[URL]
Patrick Hayes.
Anne van Kesteren; Sam Ruby. RDF Semantics. URL 10 February 2004. . 9 December 2014. W3C Recommendation. Working Draft. URL: http://www.w3.org/TR/2004/REC-rdf-mt-20040210 http://www.w3.org/TR/url-1/
[RDF-SCHEMA]
[XMLSCHEMA11-2]
Dan Brickley; Ramanathan
David Peterson; Sandy Gao; Ashok Malhotra; Michael Sperberg-McQueen; Henry Thompson; Paul V. Guha. Biron et al. RDF Vocabulary Description W3C XML Schema Definition Language 1.0: RDF Schema. (XSD) 1.1 Part 2: Datatypes 10 February 2004. . 5 April 2012. W3C Recommendation. URL: http://www.w3.org/TR/2004/REC-rdf-schema-20040210 [RFC3986] T. Berners-Lee; R. Fielding; L. Masinter. Uniform Resource Identifier (URI): Generic Syntax. January 2005. Internet RFC 3986. URL: http://www.ietf.org/rfc/rfc3986.txt http://www.w3.org/TR/xmlschema11-2/

E.2 F.2 Informative references

[MICRODATA-RDF-SUPPLEMENT]
[JSON-LD]
Manu Sporny; Gregg Kellogg; Markus Lanthaler. Microdata to RDF Supplement JSON-LD 1.0 Gregg Kellogg Editor. World Wide Web Consortium (work in progress). 22 . 16 January 2012. 2014. W3C Recommendation. URL: http://www.w3.org/TR/json-ld/
[MICRODATA-RDF-TESTS]
Gregg Kellogg; Ivan Herman. Microdata to RDF Tests Gregg Kellogg, Ivan Herman Editors. World Wide Web Consortium (work in progress). 22 March 2012. . unofficial. URL: http://w3c.github.io/microdata-rdf/tests/
[RDF-SYNTAX-GRAMMAR]
Dave Beckett.
Fabien Gandon; Guus Schreiber. RDF/XML RDF 1.1 XML Syntax Specification (Revised). 10 . 25 February 2004. 2014. W3C Recommendation. URL: http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210 http://www.w3.org/TR/rdf-syntax-grammar/
[RDFA-CORE]
Ben Adida; Mark Birbeck; Shane McCarron; Ivan Herman et al. RDFa Core 1.1: Syntax and processing rules for embedding RDF through attributes. 1.1 - Second Edition 7 June 2012. . 22 August 2013. W3C Recommendation. URL: http://www.w3.org/TR/2012/REC-rdfa-core-20120607/ http://www.w3.org/TR/rdfa-core/