Current web pages, written in HTML, contain significant inherent structured data. When publishers can express this data more completely, and when tools can read it, a new world of user functionality becomes available, letting users transfer structured data between applications and web sites. An event on a web page can be directly imported into a user's desktop calendar. A license on a document can be detected so that the user is informed of his rights automatically. A photo's creator, camera setting information, resolution, and topic can be published as easily as the original photo itself, enabling structured search and sharing.

RDFa is a syntax that expresses RDF structured data in HTML. An important goal of RDFa is to achieve this RDF embedding without repeating existing HTML content when that content is the structured data.

This document presents the major use cases where embedding structured data in HTML using RDFa provides significant benefit. Each use case explores how publishers, tool builders, and consumers benefit from RDFa. In parallel, the reader is encouraged to look at the RDFa Primer and RDFa Syntax.

In this document, we consider Publishers, Tool Builders, and Users. For simplicity, we give our fictitious users first names whose first letter matches their role: Paul, Patrick, and Peter are publishers, Tim, Tod, and Tara and tool builders, Ursula and Ulrich are users.

Paul maintains a blog and wishes to "mark up" his existing page with structure so that tools can pick up his blog post tags, authors, titles, and his blogroll, and so that he does not need to maintain a parallel version of his data in "structured format." For this purpose, Paul chooses the FOAF and Dublin Core vocabularies.

Paul's starting HTML (before RDFa) is:

and the desired RDF triples, meant to reuse the corresponding text and link targets from the HTML above, are:

A user with an RDFa-aware browser can automatically pick up Paul's list of acquaintances. An RDFa-aware newsreader can use the HTML page itself as a newsfeed, rather than seek out a separate, parallel RSS or Atom file. Importantly, if Paul edits one of his blog posts, the corresponding structured data is also automatically updated. The RDFa-aware newsreader will automatically pick up the updated title, content, and tags.

Note that many blog publishing tools already provide an "auto-update" feature: they generate multiple output formats at the same time, either by "re-baking" the entire site when an update is committed, or by dynamically generating a response to each query. With RDFa, the blog publishing engine can be significantly simplified: it only needs to produce an HTML+RDFa output, which is usable by both humans and automated feed readers. In addition, the structured data now naturally includes information not typically seen in newsfeeds: the user's blogroll, contact information, geo-location, etc., which newsreaders can begin to pick up as they see fit.

Paul sometimes gives talks on various topics, and announces them on his blog, as well as on a static page of his web site that archives all of the talks he's given. He would like to mark up these announcements with proper scheduling information, so that RDFa-enabled agents can automatically obtain the scheduling information and add it to the browsing user's calendar. Importantly, some of the rendered data might be more informal than the machine-readable data required to produce a calendar event. In addition, Paul wants to add structured data using a combination of existing Dublin Core, vcal, and some of his own terms he uses to categorize the audience of his talks.

Paul's HTML is:

and his desired RDF triples are:

When Ursula points her RDFa-enabled web browser to Paul's blog, she notices a calendar icon next to the event description. By clicking on it, she gets the option to add the event to her calendar of choice. Note that the rendered HTML uses informal language to describe the scheduling of the event, i.e. "the second day of the conference," while the structured data contains the complete iCal timestamp. In addition, the structured data also contains the Dublin Core properties. Finally, though Ursula may not know what to make of the paul:audience predicate, she can quickly find out what this predicate means using typical RDF navigation.

Tod sells an HTML-based content management system, where all documents are processed and edited as HTML, sent from one editor to another, and eventually published and indexed. He would like to build up the editorial metadata within the HTML document itself, so that the metadata is never lost.

For this purpose, Tod's software uses RDFa with non-rendered metadata. Peter, one of Tod's customers, runs Foo Magazine, which ships content to aggregators and business partners using HTML. As Peter performs editorial tasks using Tod's content management system, metadata properties are added to the document. These data are not rendered, but they can be extracted using a generic RDFa parser. Peter can thus insert a block of workflow and rights reuse metadata about the document and its components at a single point in the XHTML file and then ship the document off to a business partner.

Peter's baseline HTML, not including the RDFa, is:

Add Some Tex Mex Sizzle to Your Kid's Lunch

Amigo Corn Dogs

...

EZ Bean Tacos

...

... ]]>

Tara runs a video sharing web site. Paul frequently blogs about videos. Some are his own, which he distributes exclusively, while others are videos from Tara's site which he reviews. When Paul wants to blog about a video from Tara's site, he can paste a fragment of HTML provided by Tara directly into his blog:

Once augmented with RDFa, the HTML fragment above can be copied and pasted into Paul's blog post, carrying along with it the following triples:

When Paul uses the HTML+RDFa markup provided by Tara, the video is then available inline, in his blog, along with this structured title and licensing information about the video. A user browsing Paul's blog with an RDFa-aware browser can tell that the video shared from Tara's site is licensed under Creative Commons.

Note specifically that the HTML+RDFa markup allows Paul to display, within a single HTML page, multiple videos, each with its own license, title, and other structured information. The videos excerpted from Tara's site may be available under a Creative Commons license, while Paul's own videos are licensed under different terms.

Note also that Tara has already used the XHTML reserved keyword license in the HTML rel attribute. RDFa should play along with these existing reserved words.

Ursula is looking for a new apartment and some items with which to furnish it. She browses various RDFa-enabled web pages, including apartment listings, furniture stores, kitchen appliances, etc. Every time she finds an item she likes, she can point to it, extract the locally-relevant structured data expressed using RDFa, and transfer it to her apartment-hunting page, where it can be organized, sorted, categorized. Any additional features of the HTML that are not structured, e.g. links to photos, are conserved by the transfer.

Importantly, the structured data represented by the RDFa is easy to localize to a particular region of the rendered screen, so that Ursula can "point and click" her way to the structured data.The data Ursula aggregates can then be managed using any set of existing RDF tools for querying, sorting, and navigating.

Tim runs an RDFa-aware Semantic Wiki (as ), where users contribute content in Wiki markup, using a WYSIWYG tool, or using HTML+RDFa. In all cases, the semantic wiki produces HTML+RDFa, so that users like Ursula can transfer the structured content from one semantic wiki (or any other RDFa source) to another semantic wiki (or any other RDFa destination). In particular, Ursula may be pasting her apartment-and-furnishing finds, from , into her own Semantic Wiki.

The key principle here is that HTML+RDFa should remain transferable, almost first class: structured data from one location can be transferred to another location, where it can be rendered as HTML, from where it can be once again extracted and transferred.

Patrick writes web-based science articles where he discusses proteins, genes, and chemicals. As he has very little control over the layout—he's using a fairly constrained hosting provider—, Patrick adds RDFa to indicate the scientific components with which he's working. Note that Patrick clearly wants to reuse the large vocabularies already defined by the scientific community over the years, for example, in this case, the Uniprot vocabulary . Ulrich, a scientist, can then browse Patrick's site with an RDFa-aware browser and automatically cross-reference the proteins and genes that Patrick is talking about with his own data.

Specifically, Patrick may write the following blog post (pre-RDFa):

into which he would like to insert the following triples:

Then, Ulrich, who runs an RDFa-aware web browser (e.g. Firefox with a GreaseMonkey plugin), is provided with automatic popups with additional information for all proteins, genes, etc. in Patrick's blog. In particular, Ulrich may get links to related proteins, genes, and publications, where Patrick only added a bit of static markup.

Of course, this kind of augmented scientific browsing should be useful even for large publishers of scientific data, e.g. NCBI . Relationships between genes, proteins, and scientific literature should be expressible as easily as the HTML that embodies the same ideas.

Patrick keeps a list of his scientific publications on his web site. Using the BibTex vocabulary, he would like to provide structure within this publications page so that Ulrich, who browses the web with an RDFa-aware client, can automatically extract this information and use it to cite Patrick's papers without having to transcribe the bibliographic information.

Two important features of the BibTex vocabulary are worth highlighting for this use case: the structure is more than one-level deep, and ordering counts (i.e. who is first author?).

Specifically, Patrick may have the following HTML (pre-RDFa):

into which he would like to insert the following triples:

Paul wants to publish a vocabulary in RDFS and/or OWL. He also wants to provide a clear, human readable description of the same vocabulary. Using RDFa, the terms themselves can be mixed with a descriptive text in HTML. The RDFa engine can then extract the vocabulary in RDF/XML and/or n3 formats, to be included used directly by RDF aware applications (eg, reasoners).

Consider, specifically, the SKOS example in RDF/XML:

An HTML expression (pre-RDFa) of this SKOS concept might look like:

Expressing a SKOS vocabulary may not require any additional features to those described in prior use cases. However, it is important to consider whether RDFa can indeed express the complexity of SKOS, which may not be captured in other examples.

Some RDFa use cases may be fulfilled by microformats . In particular, Use Case #1 and part of Use Case #2 can be achieved using XFN and hCal . In such cases, microformats (possibly combined with GRDDL) provide a perfectly appropriate solution. However, in each of the use cases in this document, the microformat approach requires either building a new, complete vocabulary, or mixing several vocabularies in one single application. While this may be simple in the case of the basic existing microformats, it becomes prohibitive when large vocabularies are used, as in or simply when the number of vocabularies mixed within an application becomes too large. RDFa aims to combine, remix, and extend existing vocabularies easily, thus fully enabling , , and .

In addition, RDFa aims to define a single, non-domain-specific syntax, so that fragments of HTML+RDFa may be consistently interpretable. Specifically, consider , , and , where it is crucial that a single self-contained HTML fragment be complete enough to carry through the entire RDF structure.

The editors gratefully acknowledge contributions from:

• Mark Birbeck
• Jeremy Carroll
• Ivan Herman
• Steven Pemberton
• Guus Schreiber
• Ralph Swick
• Elias Torres