RDF Translator: A RESTful Multi-Format Data Converter for the Semantic Web

The interdisciplinary nature of the Semantic Web and the many projects put forward by the community led to a large number of widely accepted serialization formats for RDF. Most of these RDF syntaxes have been developed out of a necessity to serve specific purposes better than existing ones, e.g. RDFa was proposed as an extension to HTML for embedding non-intrusive RDF statements in human-readable documents. Nonetheless, the RDF serialization formats are generally transducible among themselves given that they are commonly based on the RDF model. In this paper, we present (1) a RESTful Web service based on the HTTP protocol that translates between different serializations. In addition to its core functionality, our proposed solution provides (2) features to accommodate frequent needs of Semantic Web developers, namely a straightforward user interface with copy-to-clipboard functionality, syntax highlighting, persistent URI links for easy sharing, cool URI patterns, and content negotiation using respective HTTP headers. We demonstrate the benefit of our converter by presenting two use cases.

In the last five years, Semantic Web developers were confronted with an increasing number of alternative syntaxes for publishing RDF content on the Web. While Uniform Resource Identifiers (URIs) and the Resource Description Framework (RDF) data model [1] could be established as de-facto components of the Semantic Web, over time there have emerged a number of competing RDF serialization formats (also syntaxes, data formats). While in the early days of the Semantic Web there only existed XML as the standard serialization format for RDF (as depicted in the Semantic Web stack¹), the most prominent syntaxes for RDF nowadays are RDF/XML, N-Triples, Notation 3 (N3) that embraces Turtle and N-Triples, RDF in attributes (RDFa), and JSON. RDFa is currently the most found syntax on the Web for publishing semantic content in Web pages [2, 3]. Microdata constitutes an alternative syntax for embedding structured data in HTML, promoted by search engine operators like Google, Microsoft, Yandex and Yahoo! in the context of schema.org², a Web vocabulary aimed to be commonly understood by all search engines. The Microdata format was initially designed under the umbrella of the Web Hypertext Application Technology Working Group (WHATWG³) and later blended with work at W3C. Unlike RDFa, it relies on a frame-based data structure (representing information as a tree) with nested groups of name-value pairs (“items”, setting the context) [4] and thus it is not fully compatible with the more flexible graph-based RDF data model. To give an example, in Microdata it is still not possible to express datatype information like in RDFa. In a blog post in 2011 [5], Manu Sporny summarized the key differences and commonalities between RDFa and Microdata (and Microformats). However, there are ongoing efforts to make Microdata and RDFa compatible with each other, carried on by the technical architecture group (TAG) at W3C. At the time of writing this paper, large parts of Microdata could already be translated seamlessly into RDF syntaxes, and vice versa.

Semantic Web developers may choose between alternative serialization formats based on personal taste or intended purpose. While RDF/XML usage traces back to the beginnings of RDF and is, similar to N-Triples, preferably used in projects with information exchange between systems and/or where large datasets are handled, RDFa and JSON (or JSON-LD) are designed for embedding RDF in HTML markup and for easing the consumption of RDF by Web applications, respectively. Turtle and Notation 3 [6] represent abbreviated syntaxes appropriate for human readability by extending N-Triples with support for compact URIs and adding syntactical sugar to shorten the fairly verbose N-Triples syntax.

It is no surprise that the above-mentioned wealth of syntaxes for the Semantic Web can pose serious limitations on interoperability between tools and at the same moment be burdensome for Semantic Web developers that have to deal with various syntactical variants. A Semantic Web developer not acquainted with RDFa, for example, may not wish to be confronted with RDF embedded in HTML using RDFa. He would rather like to read RDF data in his preferred syntax. Similarly, a JavaScript library that a Web site relies on might not support parsing RDFa from other Web pages, albeit being capable of processing JSON-LD.

Obviously, there is much value in translating between those different serialization formats. What is missing is a comprehensive online converter that can fulfill this task, and at the same time permits:

• developers to quickly test and check annotations that are encoded in less convenient formats (e.g. RDFa in HTML translated to N3),
• developers to first model in a human-friendlier format and afterwards convert to the target format (e.g. modeling in N3 and publication as RDF/XML),
• applications to better interoperate among each other.

In this paper, we present a Web service to convert between the most prominent serialization formats available on the Web. The service takes advantage of a REST-style architecture, thus being scalable, stateless and supporting HTTP GET and HTTP POST methods for translating documents or textual input. Our main motivation to develop this tool was the lack of free online services that provide quick and hassle-free conversions between the most important syntaxes for the Semantic Web. There exist such services, however, either they are not comprehensive enough by providing only conversions between a syntax pair, or their architecture is not fully REST-compliant, i.e. they may lack suitable identifiers for representing resources, not allow for content negotiation initiated by the client, or similar. Moreover, they are often technically inspired and miss out the human aspect of the development process, such as supporting syntax highlighting for better readability. Also, since so far there exist no comprehensive, RDFLib-based conversion services, this is the only service suitable for developers that consider to rely their applications on RDFLib and want to have a sandboxed playground for testing purposes.

The main contributions of our approach are summarized as follows: (1) We comprise two-way conversions for seven popular structured data formats (including Microdata) which should meet most developers’ needs; (2) we provide a user-friendly conversion service, that lowers the barriers because being available online for free and including useful design choices like keyboard shortcuts, easy copy-and-paste functionality, etc.; (3) our converter will also report syntax errors and is thus appropriate for quick syntax validation; and finally, (4) due to the REST API and HTTP content negotiation, heterogeneous sources that rely on different data formats can be integrated effortlessly.

The rest of the paper is structured as follows: Section 2 summarizes existing tools for converting between RDF formats on the Semantic Web; in Sect. 3, we introduce our conversion Web service, and in Sect. 4 we present common use cases to highlight some of the benefits of our online converter. We finally conclude our work in Sect. 5.

There exist a number of online tools for the conversion between serialization formats for RDF. Some of these tools have their origins in offline converters that are made available online as Web services, while others are pure Web services to offer conversions between various Web data formats. Some of the available Web services are limited to transformations between specific syntaxes. Consequently, we will only be able to report the most popular ones of this kind.

Any23⁴ (“Anything to Triples”) is a framework that was initially proposed as a powerful Java library and command-line tool for parsing and serializing a variety of Web document formats, used by the Sindice Semantic Web search engine. Soon it was also featured as a public REST-style Web service⁵ with form-based submission mode, support for cool URIs, GET and POST requests, content negotiation, and advanced error reporting with proper HTTP status codes. Triplr⁶ (“stuff in, triples out”) was one of the earliest RDF format converters for the Semantic Web announced in 2007. It is based on Raptor, an RDF syntax library that is part of the Redland librdf package written in C. At the time Triplr was designed, it was already capable of guessing the input format of the supplied data source, which is a very useful and much-needed functionality for online converters. Nevertheless, the service is provided as a raw REST service without any HTML-based input form fields that would support users in composing the REST URIs. RDF Distiller⁷ emerged from a similar motivation as Triplr, namely for the provision of a Ruby Gem for Semantic Web development with the Ruby programming language. It has also been deployed as a public Web service and is updated frequently as soon as new features arrive. RDF Distiller provides transformation support for a wealth of RDF syntaxes.

Omnidator⁸ (“Omnipotent Data Translator”) is a pure Web service intended as a data format translator between formats containing schema.org terms into other syntaxes. Currently, it is limited to process schema.org data in CSV and Microdata. It can turn input data into JSON, RDF/XML, or Turtle.

In parallel to the tools and services presented so far, there exist Web services solely focusing on conversions between specific data formats, e.g. transforming RDFa into RDF/XML or Notation 3 (N3), but not vice versa. RDFa 1.1 Distiller and Parser⁹ is the official RDFa parsing service maintained by W3C that translates to RDF/XML, Turtle, N-Triples and JSON-LD. The service relies on the Python RDF package RDFLib and related libraries for parsing RDFa (pyRDFa) and for serializing to the various output formats. Besides URI and textual input it allows to upload local files with RDFa embedded in various syntaxes like HTML5, XHTML, XML, Atom, and SVG. Similar, but not as powerful services for converting RDFa to other Web formats are provided by the RDFa Online Parser¹⁰ and RDFa Lite 2 RDF Extractor¹¹. The latter is powered by node.js. A similar RDF extractor also exists for the Microdata syntax¹².

None of the Web services presented so far support the conversion from traditional RDF syntaxes to RDF embedded in Web document formats like RDFa and Microdata in HTML. First attempts to do this resulted in the proposal of the Snippet Style approach for RDFa [7]. In this context, an online converter termed RDF2RDFa¹³ was presented to turn RDF/XML content into RDFa. Later followed a Microdata variant of that service, namely RDF2Microdata¹⁴. To the best of our knowledge, these services were the first to generate RDFa or Microdata snippets for embedding RDF content in HTML. A similar functionality is provided by the RDFa serializer plugin in the PHP ARC2 library, showcased online¹⁵ as a Web service.

A powerful, yet outdated and apparently shutdown service was Talis Morph¹⁶ that was able to transform between different Semantic Web formats. Furthermore, there are some RDF validators that provide in addition to their core functionality, i.e. the validation, also conversion functionality. rdf:about¹⁷, for example, is providing an input text area to convert between RDF/XML and Notation 3 (including Turtle and N-Triples).

In this section, we present RDF Translator¹⁸, a Web service for bidirectionally converting between various RDF data formats, namely RDFa, Microdata, RDF/XML, Notation 3, N-Triples, RDF/JSON, and JSON-LD. Unlike most of the tools presented in Sect. 2, our online converter is a comprehensive and convenient Web service with having Semantic Web developers in mind.

Subsequently we outline the service architecture, followed by the description of the user interface and what features there are to ensure the developer-friendliness of our Web service. This is afterwards complemented by the specification of the underlying REST API and the related compliance with best practices in Web technology design, i.e. cool URIs, content negotiation, and CORS support. We further address how we solved prefix resolution for better readability of the resulting output.

Service Architecture

Fig. 1 depicts the architecture of RDF Translator. At the core of the Web service is a powerful REST API that handles all incoming requests, be it direct requests from HTTP-capable client applications, browser bookmarklets, or indirect requests via the Web user interface. The REST API supports both HTTP GET and HTTP POST request methods, whereby the latter is more suitable than the former for submitting raw data to be converted by the service. For human users the Web service offers an intuitive Web user interface, which provides two options, namely the provision of a Web resource URI which contents are to be converted, or raw textual input to be translated into a target format. More details about the Web user interface follow in Sect. 3.2.

The converter is implemented as a Google AppEngine Web service (based on the webapp2 Python framework) and can thus scale up to many parallel requests given that Google allows for paid plans with quite flexible resource allocation. The service takes advantage of the RDFLib library¹⁹ for parsing, manipulating and serializing RDF graphs. With respect to covering the full conversion cycle, RDFLib in its current version is missing serializers for RDFa and Microdata. Initially we tried to fill this gap by using RDF2RDFa and RDF2Microdata (see Sect. 2), however, their outputs are unsatisfying because maintenance of these services has stopped long time ago, so we decided to provide two custom plugins compatible with RDFLib that we made publicly available online²⁰. The full source code of the Web service has been published as a Bitbucket repository²¹. It is licensed under a LGPL license and people are invited to run their own service instances on Google AppEngine.

Web User Interface

The user interface was developed with user-friendliness in mind, thus kept clean and straightforward. Fig. 2 illustrates a screenshot of the Web front end of the Web service, sketching the input box, the syntax-highlighted output and the copy-to-clipboard button to ease copy-and-paste. It further can be seen that the input box consists of tabs, one for the URI submission (default option) and the other one for the textual input. In the given screenshot the URI tab is activated, thus showing a URI input field along with the submit button and selectors for the input and output formats. The data formats currently supported by the Web service are:

• RDFa,
• Microdata,
• RDF/XML (standard syntax, plus a more concise XML syntax, i.e. replacing rdf:Description nodes by typed nodes),
• N3,
• N-Triples,
• RDF-JSON (standard syntax, plus a more concise JSON syntax, i.e. using namespace prefixes instead of full URIs), and
• JSON-LD.

Furthermore, the input format can be determined automatically by means of content negotiation, under the premise that the correct media type was supplied. Otherwise, the automatic detection of the document format fails with an error message.

The Web front end consists of a HTML5 document with JavaScript (JQuery) for user interaction, asynchronous communication, and manipulation of the document tree.

URI Submission

The main element for the URI submission is the input text field for entering the URI. As long as there is input missing or the supplied URI is invalid, the URI input field remains red-shaded. This is a feature supported by HTML5 which attracts attention of the user to prevent him from submitting incorrect data. However, for simple HTTP addresses the http://-prefix need not be explicitly supplied with the URI. According to this, it is possible to shorten http://www.example.com with www.example.com, but not https://www.example.com. For helping the user to get started with the Web service, the URI input field is pre-filled with a Web page URI that contains semantic descriptions.

The Web service provides key shortcuts for faster form submissions. If the page focus is in the URI input field or in the input or output selectors, a simple keystroke (pressing the return-key) suffices to trigger the conversion process. So there is actually no need to press the Submit-button, which may help speed up repetitive tasks like the tedious task of translating a moderate list of URIs into other formats.

For sharing results with other people the Web service returns persistent URIs together with the conversion output. Unlike as for the textual input mode, for URI submissions there appears an additional grey box below the converter output. It contains two persistent links for easy sharing with other developers, namely one link that refers to the syntax-highlighted version of the output for sharing between humans, and a second link that points to the raw output format with the proper media type supplied, hence being suitable for integration with other Web applications.

Textual Input

The textual input allows developers to enter raw input data into a text area. Since users submit plain data, the automatic format detection does not work for this type of transformation unless the format is guessed by chance. In other words, content negotiation fails because there is no metadata available as when calling a URI that returns HTTP response headers with content type declarations supplied.

Developers are again actively supported by being offered working examples for every type of serialization format to become acquainted more easily with the Web service.

Syntax Highlighting

Syntax highlighting is a visual means that most developers using advanced text editors to write and read code are familiar with. Similar to programming languages, also the different syntax variants for RDF can be made better readable for humans by highlighting terms according to grammar and keywords. Our Web service applies syntax highlighting to the output of the translated contents in the Web interface or, if requested explicitly, using the REST API.

The Web service accomplishes syntax highlighting by virtue of the sophisticated Pygments²² library for Python. Pygments supports all required syntaxes, i.e. RDFa and Microdata using the HTML formatter; RDF/XML taking advantage of the XML formatter; RDF/JSON and JSON-LD by use of the JSON lexer; and N3 and N-Triples by means of a custom-built Notation 3 lexer.

Bookmarklets

For developers that do not prefer to visit the Web service every time they find an interesting Web resource with embedded RDFa or Microdata, bookmarklets are a convenient means for quickly extracting the contained structured markup of any Web page and presenting it in the developer’s preferred syntax. Bookmarklets are JavaScript snippets suitable for being added to bookmark folders and toolbars of modern browsers. This way a simple click on the created bookmark is sufficient to translate the contents of the current Web resource into an arbitrary target RDF syntax. The bookmarklet code used to convert structured data in the form of RDFa to syntax-highlighted Notation 3 code looks as follows:

javascript:location.href='http://rdf-translator.appspot.com/convert/rdfa/n3/html/'+encodeURIComponent(location.href);

On the landing page of our Web service we are providing a comprehensive matrix table with all possible combinations of syntax conversions.

Other Features

In addition to the features presented so far, the Web user interface can further assist human users in various aspects. This includes:

• copy-to-clipboard functionality that saves the effort for selecting and copying the output text to the system clipboard (see Fig. 2),
• feedback link (not visible in Fig. 2) for contacting the developers, and
• verbose error messages that can provide helpful explanations about failed translations.

http://rdf-translator.appspot.com/convert/<source>/<target>/<uri>

http://rdf-translator.appspot.com/convert/<source>/<target>/html/<uri>

curl "http://rdf-translator.appspot.com/convert/xml/n3/http://xmlns.com/foaf/spec/index.rdf"

curl --data-urlencode content="@prefix : <http://example.org/#> . :a :b :c ." http://rdf-translator.appspot.com/convert/n3/nt/content

<http://example.org/#a> <http://example.org/#b> <http://example.org/#c> .

curl --data-urlencode content@example.n3 http://rdf-translator.appspot.com/convert/n3/nt/content > example.nt

Access-Control-Allow-Origin: *

The typical Semantic Web development process involves many requirements that are insufficiently addressed by many of the tools presented in Sect. 2. Such requirements range from technical solutions to active user support during the development and testing of Semantic Web artifacts. The technical aspect involves providing an otherwise unsupported document format in the syntax preferred by a consuming application. Similarly, in collaborative tasks it often proves useful to be able to share human-readable representations of data with others, such as exchanging Notation 3 code instead of a Web document with RDFa in HTML.

Based on this intuition, we defined two requirements that we successfully applied in real use cases and that we think many of the other existing Web services for RDF syntax conversions are not able to address well.

RewriteCond %{HTTP_ACCEPT} text/plain
RewriteRule ^ns$ http://rdf-translator.appspot.com/convert/n3/nt/http://www.stalsoft.com/ontologies/xro/ns.n3 [P,L]

RewriteRule \.nt$ http://rdf-translator.appspot.com/convert/n3/nt/http://www.stalsoft.com/ontologies/xro/ns.n3 [P,L]

Syntax Highlighting

Translate a RDF/XML ontology document to syntax-highlighted Notation 3 for viewing in the Web browser.

RDF Translator supports raw output delivered with the respective media types and HTML-rendered output with syntax highlighting. The latter is achieved by including /html in the hierarchical part of the URI in front of the specification of the input URI or, for POST requests, right before the content value in the URI string. Let us assume that we would like to show the contents of the Exchange Rate Ontology in human-readable Notation 3 with syntax highlighting enabled (Fig. 3). The corresponding URI is:

http://rdf-translator.appspot.com/convert/xml/n3/html/http://purl.org/xro/ns

There are three important technical details in this example that need further explanation: First, RDF Translator follows HTTP redirect links, because the short URI http://purl.org/xro/ns links to the actual location of the deployment at http://www.stalsoft.com/ontologies/xro/ns. Second, it requests the RDF/XML representation of the document using HTTP content negotiation. And finally, it translates the contents to Notation 3 and, using Pygments, wraps them into syntax-highlighted HTML code for viewing in the Web browser.

The bookmarklet feature presented in Sect. 3 is taking advantage of this functionality, i.e. there is one among the 72 bookmarklets that is able to show markup encoded as RDF/XML in syntax-highlighted Notation 3. Furthermore, this functionality has also been integrated into a browser extension for Google Chrome, the Grome extension²⁷ that detects GoodRelations markup, either as RDFa or Microdata, in Web pages and allows to quickly show the embedded metadata in the preferred syntax.

In this paper we presented RDF Translator, a RESTful Web service that comes with a developer-friendly user interface and a REST API. The Web service is intended as a comprehensive solution for translating between the most popular serialization formats currently available on the Semantic Web. Our proposal does not only focus on the technical aspects of supporting the development of Semantic Web applications with syntax transformation capability, but also on collaborative aspects of the development process. What makes our solution unique among the Web services presented in Sect. 2 is the combination of features like the bidirectional conversion capability of a number of popular RDF data formats, the possibility of syntax highlighting for all of the supported serialization formats, link sharing functionality for better collaboration, a clean and straightforward Web user interface with active user support, and compliance with cutting-edge Web technologies.

We frequently update the libraries that underlie our Web service to the most recent versions, thus we think we can reflect well the latest changes to the different formats. As such we think our service represents a well-maintained, authoritative conversion service on the Web that can be a useful tool for a large number of Semantic Web developers.

As future work we consider to improve error detection and verbosity of our Web service in terms of providing status codes and corresponding error messages like the Any23 Web service is already doing. This would improve interoperability with Web applications that take advantage of RDF Translator and at the same time it would allow developers to provide us with more accurate feedback.

1. Manola, F., Miller, E.: RDF Primer, http://www.w3.org/TR/rdf-primer/, (2004).↩
2. Mika, P.: Microformats and RDFa Deployment Across the Web, http://tripletalk.wordpress.com/2011/01/25/rdfa-deployment-across-the-web/, (2011).↩
3. Mühleisen, H., Bizer, C.: Web Data Commons – Extracting Structured Data from Two Large Web Corpora. Proceedings of the WWW2012 Workshop on Linked Data on the Web (LDOW2012). , Lyon, France (2012).↩
4. Hickson, I.: HTML Microdata, http://www.w3.org/TR/microdata/, (2012).↩
5. Sporny, M.: An Uber-comparison of RDFa Microdata and Microformats, http://manu.sporny.org/2011/uber-comparison-rdfa-md-uf/, (2011).↩
6. Berners-Lee, T., Connolly, D.: Notation3 (N3): A Readable RDF Syntax, http://www.w3.org/TeamSubmission/n3/, (2011).↩
7. Hepp, M., García, R., Radinger, A.: RDF2RDFa: Turning RDF into Snippets for Copy-and-Paste. Poster and Demo Proceedings of the 8th International Semantic Web Conference (ISWC 2009). , Washington, DC, USA (2009).↩
8. Fielding, R.T.: Architectural Styles and the Design of Network-based Software Architectures, (2000).↩
9. Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P., Berners-Lee, T.: RFC 2616: Hypertext Transfer Protocol – HTTP/1.1, http://www.ietf.org/rfc/rfc2616.txt, (1999).↩
10. Berners-Lee, T.: Cool URIs don’t change, http://www.w3.org/Provider/Style/URI, (1998).↩
11. Sauermann, L., Cyganiak, R.: Cool URIs for the Semantic Web, http://www.w3.org/TR/cooluris/, (2008).↩
12. van Kesteren, A.: Cross-Origin Resource Sharing, http://www.w3.org/TR/cors/, (2013).↩