In the following examples, for brevity assume that the following namespace prefixes are defined:

cc:	http://creativecommons.org/ns#
dc:	http://purl.org/dc/elements/1.1/
ex:	http://example.org/
foaf:	http://xmlns.com/foaf/0.1/
rdf:	http://www.w3.org/1999/02/22-rdf-syntax-ns#
rdfs:	http://www.w3.org/2000/01/rdf-schema#
svg:	http://www.w3.org/2000/svg
xh11:	http://www.w3.org/1999/xhtml
xsd:	http://www.w3.org/2001/XMLSchema#
biblio:	http://example.org/biblio/0.1
taxo:	http://purl.org/rss/1.0/modules/taxonomy/

This document uses the following terminology defined in :

URI reference

We also add two further concepts, an [&syntax.name; element] and the [context statement] both of which are explained in the processing section.

The aim of &syntax.name; is to allow [RDF graph]s to be carried in XML documents of any type. An [RDF graph] comprises [node]s linked by relationships. The basic unit of a graph is a [triple], in which a subject [node] is linked to an object [node] via a [predicate]. The subject [node] is always either an [RDF URI reference] or a [blank node], the predicate is always an [RDF URI reference], and the object of a statement can be an [RDF URI reference], a [literal], or a [blank node].

In &syntax.name;, a subject [RDF URI reference] is indicated using the attribute about and predicates are represented using one of the attributes property, rel, or rev. Objects which are [RDF URI reference]s are represented using the attribute href, whilst objects that are [literal]s are represented either with the attribute content, or the content of the element in question.

All [RDF URI references] are subject to xml:base . Note that this means that in the absence of an xml:base attribute, the document containing the RDF statements is itself the base.

An example follows to show how xml:base affects the subject:

The triples generated would be as follows:

In order to allow for the compact expression of RDF statements, RDFa uses CURIEs (Compact URIs) . The rel, rev, and property attributes accept CURIE-only datatypes, while href and about accept mixed CURIE/URI data. In particular, the following notation is a valid RDFa statement:

which generates the following triple, as expected:

The main idea behind the syntax for RDFa is that existing data should be easy to update to convey RDF triples. Thus, the bulk of RDFa can be expressed using only attributes applied to existing elements within the XML document, specifically about, rel, rev, property, href, and content. In addition, it should be possible to represent a [triple] using only one XML element. In this way it owes more to 'flat' syntaxes like RDF/N3 than it does to RDF/XML , despite its use of XML.

For example, given an XHTML chunk as follows:

a simple attribute augmentation can yield an RDF triple:

which yields:

Note that, in the above example, had "Mark Birbeck" not been enclosed in an existing span element, a new one could have simply been used with about and property as its only two attributes.

Similarly, links can be augmented to express RDF triples. Consider an XHTML chunk:

When the RDF object is a URI, the RDF predicate is designated using rel:

which yields:

It's important to note that the various RDFa attributes can be used on any existing element of the XML dialect. Note also that one can express a reverse relationship using the rev attribute. For example, if the photo in question is actually a depiction of Mark, one could write:

which would yield:

Both relations can be expressed simultaneously:

which then yields both triples:

And it's also possible to go further and add the attributes used for denoting statements in which the object is a [literal]:

which would then yield:

It's possible to do all of this without ambiguity, since the property attribute always denotes a predicate in a statement in which the object is a [literal], whilst the rel and rev attributes always denote a predicate in a statement in which the object is a [URI reference]. Put a different way, property always works with content, whilst rel and rev work with href.

Of course, the more natural way to express the three above triples is to strive to make all metadata literals and URIs meaningful within the host XML dialect. Specifically, in the case of XHTML2, it makes sense to render as much of the useful metadata as possible and use RDFa to mark up this rendered data. The following XHTML thus generates the same triples shown above.

The value of the about attribute is inherited from parent elements. The following XHTML thus generates the very same triples as the XHTML above.

A second feature of RDFa is that it is possible to use parts of the host document to provide the [subject] of a [triple]. This marks RDFa from other approaches to serialising RDF, in that the the same syntax can now be used to make statements about parts of a document, and external documents.

It is possible to make such statements using the syntax introduced in the examples above:

However, two problems arise: the href causes the entire quotation to become a clickable link, which may not be the desired visual effect, and only one triple can be expressed. Thus, RDFa provides another mechanism, using the special link or meta element without a specified [subject]. In such cases, the [triple] concerns the parent element. This allows the example above to be recast as follows:

This syntax (omitting the about attribute to refer to the parent element) only applies to the elements link and meta, which means that even without an id attribute, the following statement is still 'about' the blockquote element, and not the document as a whole:

If more than one piece of metadata needs to be attached to the same element, then additional link or meta elements can be added:

Now we have attached two pieces of metadata to the blockquote element -- the source of the quote, and its author.

Using qualifying statements, RDFa allows a single XML dialect document to include multiple RDF entities. Relations between the various entities of a given page can also be defined using RDFa notation.

Consider the following XHTML, which defines two RDF entities of type taxo:topic, two RDF entities of type biblio:Publication, metadata pertinent to each publication, including dc:title and dc:creator, and relations of type taxo:topics between the publications and tags:

This yields the expected triples:

Beyond this theoretical example, this application of RDFa is particularly useful for formats like FOAF. (See examples.)

The previous series of examples may mislead one to think that RDFa statements are only contextual, only meant to qualify existing elements. However, as the first examples implied, a fixed about attribute can be used to specify a global subject. It is actually quite easy to make independent, global RDF statements. Statements like:

will produce the same triple no matter where they're located in the document:

An [&syntax.name; element] is defined as any XML element that contains one or more RDFa attributes: about, property, rel, rev, href, content. Processing proceeds by examining each [RDFa element] in turn. The [RDFa element] under consideration at any time is the [current statement], and its parent element is the [context statement]. Note that the [context statement] does not need to be an [RDFa element]. RDFa also includes a datatype attribute. The presence of that attribute does not by itself designate an [RDFa element].

As each [RDFa element] is examined, the processor tries to establish the RDF triples it generates. Each of the attributes rel, rev, and property can express one or more triples: each accepts space-separated values, and each such value the predicate for one triple. It makes sense, then, for the processor to start with identifying the predicate of a triple, then to figure out the triple's subject and object.

The predicate of a statement is specified using a property, rel or rev attribute. These attributes can be placed on any element in a document, and -- although readability may suffer -- can even co-exist on the same element. Each of these attributes accepts space-separated CURIEs, each of which expresses exactly one triple. The attribute indicates the type of resolution to use for the subject and object of the triple. For simplicity, we assume an attribute value of a single CURIE. We explain the space-separated multiple-values situation later.

The object of the statement can be set using one of the attributes content or href. Which attribute is used depends on how the predicate is indicated. If the predicate is set using property then the object is a [literal], and its value is given by the content attribute or the element content. If the predicate is set with the rel attribute, then the object is a non-literal whose value depends on the presence and value of href attribute. If the predicate is expressed with the rev attribute, then the object will be obtained using subject resolution as defined in the next section, while this section explains how to set that predicate's subject.

While the predicate and object resolution are relatively local to the RDFa element on which the corresponding attributes reside, subject resolution can be a little bit more complicated. Importantly, the [context statement] is highly relevant in determining the subject. Note that, when the predicate is determined by the rev attribute, the subject resolution described here applies to the object of the triple under consideration, while the subject is determined using object resolution, as described in the previous section.

At a high level, the subject of a statement is determined by the about attribute, either on the element or on the closest parent of that element. Two exceptions to that rule exist. First, if a closer parent element includes a rel or rev attribute with no href, then the subject is the CURIE/URI that corresponds to that parent element (as described previously in object resolution.) Second, if the [RDFa element] under consideration is a META or LINK without an about, then the subject is the immediate parent element's CURIE/URI equivalent.

This section will contain a summary of the syntax.

When a property predicate is used in RDFa, the object is expected to be a literal. This literal can be optionally typed by a datatype attribute within the same RDFa element. The absence or presence of this attribute has a significant impact on the interpretation of the literal.

A [blank node] is generated explicitly when an [RDFa statement] uses a bnode CURIE as its subject. A [blank node] can be generated more implicitly when an XML element without an about attribute has meta or link children elements, also without about attributes of their own. In the latter case, the [unique anonymous ID] generated to identify the [blank node] is associated with the [context statement] of the meta and link elements. This allows a number of statements to be made about the same [blank node].

For example, to establish relationships between a [blank node] and literals or URIs, one can use the implicit [blank node] construction of our earlier example, repeated here:

This would generate the following [triple]s:

One could also use the more explicit declaration:

To establish relationships between [blank node]s, the [unique anonymous ID] must be set explicity using a CURIE bnode as subject or object. For example, if our desired output is the following [triple]s:

we could use the following XHTML:

or, alternatively, if we wish to partly render the information in XHTML:

RDFa partially supports reification.

During subject resolution (which could be triggered by object resolution for a rev attribute), the processor may traverse up the DOM tree in search of an about attribute. If a link or meta element is encountered before an about attribute is found, and if this link or meta element itself does not have an about attribute, then the subject (or, again in the case of rev, object) is resolved as the [RDFa statement] represented by this link or meta element.

For example, the following XHTML:

will yield the following triples:

which means that "Mark Birbeck" is the creator of the current document, that this document is licensed under a Creative Commons license, and that "Ben Adida" is the creator of that licensing statement, not of the document itself.

One of the advantages of using the same syntax to make general statements as well as statements about a document is that in many cases a document can carry its own metadata. For example, if an XHTML document contains a navigable link to the Creative Commons license, this link can also be used to express metadata:

This chunk of XHTML will generate the same triples, no matter what other XHTML contains it:

FOAF requires the definition of at least two RDF entities: the FOAF person, and the FOAF homepage, which cannot be the same. Thus, the following XHTML can be used to represent a FOAF record:

which yields the correct FOAF triples:

If one wants to make the foaf:Person a blank node, then the only change required is taking out the id="person" from the span element, which then yields the following triples: