Share on
http://www.productontology.org/
On this page: Usage Examples schema.org/Microdata Facebook OGP RDF/XML Dump FAQs Caching Policy License Contact Information Acknowledgments References
Breaking news: schema.org has just implemented our proposal to define an additionalType property with the use of this service in mind!
| Wikipedia Entry | Class Identifier | Representation |
|---|---|---|
| Apple | http://www.productontology.org/id/Apple | [RDF/XML] [N3/Turtle] [HTML] |
| Manure_spreader | http://www.productontology.org/id/Manure_spreader | [RDF/XML] [N3/Turtle] [HTML] |
| Racing_bicycle | http://www.productontology.org/id/Racing_bicycle | [RDF/XML] [N3/Turtle] [HTML] |
| Soldering_iron | http://www.productontology.org/id/Soldering_iron | [RDF/XML] [N3/Turtle] [HTML] |
| Sweet_potato | http://www.productontology.org/id/Sweet_potato | [RDF/XML] [N3/Turtle] [HTML] |
GoodRelations is a standardized vocabulary (also known as "schema", "data dictionary", or "ontology") for product, price, and company data that can (1) be embedded into existing static and dynamic Web pages and that (2) can be processed by other computers. This increases the visibility of your products and services in the latest generation of search engines, recommender systems, and other novel applications.
schema.org is an entry-level alternative for marking up pages for search engines.
While the classes provided by this service are initially meant to complement GoodRelations and schema.org, they can be used for any other Semantic Web or Linked Open Data application as well.
Wikipedia page about "Hammer": http://en.wikipedia.org/wiki/Hammer
| Prefix | pto: |
|---|---|
| Ontology ID | http://www.productontology.org/# |
| Namespace | http://www.productontology.org/id/ |
| Class Identifier | http://www.productontology.org/id/Hammer |
| Representation | http://www.productontology.org/doc/Hammer |
| RDF/XML (single class) | http://www.productontology.org/doc/Hammer.rdf |
| N3/Turtle (single class) | http://www.productontology.org/doc/Hammer.ttl |
| RDF/XML (dump file) | http://www.productontology.org/dump.rdf |
| HTML | http://www.productontology.org/doc/Hammer.html |
You can use this ontology to describe any object for which a matching entry in the English Wikipedia exists. If you already know the correct URI for the English Wikipedia page, simply cut off the Wikipedia namespace part
http://en.wikipedia.org/wiki/
from the Wikipedia URI, e.g.
http://en.wikipedia.org/wiki/Hammer
and replace it by
http://www.productontology.org/id/
which will e.g. give you
http://www.productontology.org/id/Hammer
Then you can use this URI to indicate that your object is a hammer:
foo:myHammer rdf:type <http://www.productontology.org/id/Hammer> .In Microdata syntax with the schema.org vocabulary, you should add the full URI of a class from this site as an additional type by using the additionalType property of http://schema.org/Product as follows:
<div itemscope itemtype="http://schema.org/Product">
<link itemprop="additionalType" href="http://www.productontology.org/id/Hammer" />
<!-- other schema.org properties go in here -->
</div>
Thanks to the many links between the multiple language editions of Wikipedia, you can search for the best class in your favorite language, e.g. in the German or Italian Wikipedia, and then click on the English translation on the left-hand side to get to the matching page in the English Wikipedia:
For describing typical characteristics of the object, like weight, depth, length, width, color, or condition, you can use the predefined GoodRelations properties:
You can also use relevant properties from other GoodRelations-compliant vocabularies, like those for Vehicles or Tickets.
When used in combination with http://schema.org/Product, you can also use all standard properties defined for this type, e.g. model or productID.
One of the most powerful usages of the class definitions from this site is to describe the type of your page and product for the schema.org product markup in Microdata syntax much more precisely.
Simply add the full URI of a class from this site, e.g. http://www.productontology.org/id/Hammer as an additional type as follows:
<div itemscope itemtype="http://schema.org/Product">
<link itemprop="additionalType" href="http://www.productontology.org/id/Hammer" />
<!-- other schema.org properties go in here -->
</div>
Note: In HTML5, it is valid to use the <link> element in the body of a HTML document.
Here is a complete example:
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<title>An offer to sell a / some Hammer</title>
</head>
<body>
<div itemscope itemtype="http://schema.org/Product" itemid="#product">
<link itemprop="additionalType" href="http://www.productontology.org/id/Hammer" />
<span itemprop="name">.. a short name for the object ...</span>
Product description:
<span itemprop="description">... a longer description ...</span>
<div itemprop="offers" itemscope itemtype="http://schema.org/Offer" itemid="#offer">
<span itemprop="price">$19.99</span>
<link itemprop="availability" href="http://schema.org/InStock" />In stock
</div>
</div>
</body>
</html>
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix pto: <http://www.productontology.org/id/> .
@prefix gr: <http://purl.org/goodrelations/v1#> .
@prefix foo: <http://example.com/> .
# The object
foo:myObject a <http://www.productontology.org/id/Hammer> ;
a gr:SomeItems ;
gr:name "... a short name for the object ..."@en ;
gr:description "... a longer description ..."@en .
# The agent (person or company) who is offering it
foo:ACMECorp a gr:BusinessEntity ;
gr:legalName "ACME Corp" ;
gr:offers foo:Offer .
# The offer to sell it
foo:Offer a gr:Offering ;
gr:includes foo:myObject;
foaf:page <http://URI_of_the_page_containing_the_offer.com>;
gr:hasBusinessFunction gr:Sell ;
gr:validFrom "2011-01-24T00:00:00+01:00"^^xsd:dateTime ;
gr:validThrough "2011-12-24T00:00:00+01:00"^^xsd:dateTime ;
gr:hasPriceSpecification
[ a gr:UnitPriceSpecification ;
gr:hasCurrency "USD"^^xsd:string ;
gr:hasCurrencyValue "19.99"^^xsd:float ;
gr:validThrough "2011-12-24T00:00:00+01:00"^^xsd:dateTime ] .
Note: Replace gr:SomeItems (http://purl.org/goodrelations/v1#SomeItems) by gr:Individual if you are describing a unique object of that kind (e.g. antique furniture).
<!DOCTYPE html>
<html version="HTML+RDFa 1.1" xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<title>An offer to sell a / some Hammer</title>
</head>
<body>
<div xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:gr="http://purl.org/goodrelations/v1#"
xmlns:pto="http://www.productontology.org/id/"
xmlns:foo="http://example.com/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#">
<!-- The agent (person or company) who is offering it -->
<div about="#ACMECorp" typeof="gr:BusinessEntity">
<div property="gr:legalName">ACME Corp</div>
<div rel="gr:offers">
<!-- The offer to sell it -->
<div about="#offer" typeof="gr:Offering">
<div rel="gr:hasBusinessFunction" resource="http://purl.org/goodrelations/v1#Sell"></div>
<div rel="gr:includes">
<!-- The object -->
<div about="#myObject" typeof="http://www.productontology.org/id/Hammer">
<div rel="rdf:type" resource="http://purl.org/goodrelations/v1#SomeItems"></div>
<div property="gr:description" xml:lang="en">... a longer description ...</div>
<div property="gr:name" xml:lang="en">.. a short name for the object ...</div>
</div>
</div>
<div rel="foaf:page" resource="http://URI_of_the_page_containing_the_offer"></div>
<div rel="gr:hasPriceSpecification">
<div typeof="gr:UnitPriceSpecification">
<div property="gr:hasCurrency" content="USD" datatype="xsd:string">$ </div>
<div property="gr:hasCurrencyValue" datatype="xsd:float">19.99</div>
<div property="gr:validThrough" content="2011-12-24T00:00:00+01:00"
datatype="xsd:dateTime"></div>
</div>
</div>
<div property="gr:validFrom" content="2011-01-24T00:00:00+01:00"
datatype="xsd:dateTime"></div>
<div property="gr:validThrough" content="2011-12-24T00:00:00+01:00"
datatype="xsd:dateTime"></div>
</div>
</div>
</div>
</div>
</body>
</html>
Note: Replace gr:SomeItems (http://purl.org/goodrelations/v1#SomeItems) by gr:Individual if you are describing a unique object of that kind (e.g. antique furniture).
<?xml version="1.0" encoding="UTF-8" ?>
<rdf:RDF xmlns:gr="http://purl.org/goodrelations/v1#"
xmlns:pto="http://www.productontology.org/id/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:foo="http://example.com/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<!-- The object -->
<rdf:Description rdf:about="http://example.com/myObject">
<rdf:type rdf:resource="http://www.productontology.org/id/Hammer"/>
<rdf:type rdf:resource="http://purl.org/goodrelations/v1#SomeItems"/>
<gr:name xml:lang="en">... a short name for the object ...</gr:name>
<gr:description xml:lang="en">... a longer description ...</gr:description>
</rdf:Description>
<!-- The agent (person or company) who is offering it -->
<gr:BusinessEntity rdf:about="http://example.com/ACMECorp">
<gr:legalName>ACME Corp</gr:legalName>
<gr:offers rdf:resource="http://example.com/Offer" />
</gr:BusinessEntity>
<!-- The offer to sell it -->
<gr:Offering rdf:about="http://example.com/Offer">
<gr:includes rdf:resource="http://example.com/myObject" />
<foaf:page rdf:resource="http://URI_of_the_page_containing_the_offer"/>
<gr:hasBusinessFunction rdf:resource="http://purl.org/goodrelations/v1#Sell"/>
<gr:validFrom rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">
2011-01-24T00:00:00+01:00</gr:validFrom>
<gr:validThrough rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">
2011-12-24T00:00:00+01:00</gr:validThrough>
<gr:hasPriceSpecification>
<gr:UnitPriceSpecification>
<gr:hasCurrency rdf:datatype="http://www.w3.org/2001/XMLSchema#string">USD</gr:hasCurrency>
<gr:hasCurrencyValue rdf:datatype="http://www.w3.org/2001/XMLSchema#float">19.99</gr:hasCurrencyValue>
<gr:validThrough rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">
2011-12-24T00:00:00+01:00</gr:validThrough>
</gr:UnitPriceSpecification>
</gr:hasPriceSpecification>
</gr:Offering>
</rdf:RDF>
Note: Replace gr:SomeItems (http://purl.org/goodrelations/v1#SomeItems) by gr:Individual if you are describing a unique object of that kind (e.g. antique furniture).
prefix foaf: <http://xmlns.com/foaf/0.1/>
prefix xsd: <http://www.w3.org/2001/XMLSchema#>
prefix pto: <http://www.productontology.org/id/>
prefix gr: <http://purl.org/goodrelations/v1#>
prefix foo: <http://example.com/>
# Find the cheapest offer for a Hammer
SELECT * WHERE{
?company gr:offers ?offer .
?offer a gr:Offering .
?offer gr:hasBusinessFunction gr:Sell .
OPTIONAL {?offer rdfs:label ?label } .
OPTIONAL {?offer gr:name ?label } .
OPTIONAL {?offer rdfs:comment ?label } .
OPTIONAL {?offer gr:description ?label } .
?offer gr:hasPriceSpecification ?p .
?p a gr:UnitPriceSpecification .
?p gr:hasCurrency ?currency .
?p gr:hasCurrencyValue ?price .
?offer gr:includes ?product .
?product a <http://www.productontology.org/id/Hammer> .
}
ORDER BY (?price)
LIMIT 10
You can also use the class definitions from this site for better describing the type of your page or product for the Facebook Open Graph Protocol.
Simply define the namespace prefix pto: in the <html> element of your page
<html version="HTML+RDFa 1.1"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:pto="http://www.productontology.org/id/"
>and use the compact URI (CURIE), e.g. pto:Hammer in combination with og:type as follows:
<meta property="og:type" content="pto:Hammer"/>
Here is a complete example:
<!DOCTYPE html>
<html version="HTML+RDFa 1.1" xmlns="http://www.w3.org/1999/xhtml" lang="en"
xmlns:og="http://ogp.me/ns#"
xmlns:fb="http://www.facebook.com/2008/fbml"
xmlns:pto="http://www.productontology.org/id/">
<head>
<meta http-equiv="Content-Type" content="application/xhtml+xml; charset=UTF-8"/>
<title>Example for Facebook Opengraph Protocol on a page describing a(n)/some Hammer</title>
<meta property="og:title" content="Example for Facebook Opengraph Protocol on a page describing a(n)/some: Hammer"/>
<meta property="og:type" content="pto:Hammer"/> <!-- this is the important line -->
<meta property="og:url"content="http://www.uri_for_the_item.com"/>
<meta property="og:image" content="http://www.uri_of_product_image.com/image.png"/>
<meta property="og:site_name" content="Name of Site"/>
<meta property="fb:admins" content="USER_ID"/>
<meta property="og:description" content="long text describing the product"/>
</head>
<body>
<!-- Human-readable page content -->
Example for combining the Facebook Opengraph Protocol with http://www.productontology.org for more specific ogp:type statements.
<!-- GoodRelations markup to be added here -->
</body>
</html>
You can fetch an RDF/XML representation of all classes that (1) have been requested several times and (2) that are not disambiguation pages in Wikipedia from
http://www.productontology.org/dump.rdf
By default, it just returns the 1000 most frequently requested classes. You can fetch all classes by using the parameters limit and offset as follows:
http://www.productontology.org/dump.rdf?limit=x&offset=y
The default and maximum value for limit is 1000, the default for offset is 0. The HTTP response headers will contain additional parameters that help fetching all classes:
X-productontology-offset: <offset> X-productontology-limit: <limit> X-productontology-results: <number of results returned>
So you can create a simple loop that increases the offset by a fixed number until the number of results returned is less than the requested number of items.
Note 1: This dump file does neither include textual class definitions (rdfs:comment) nor non-English class labels. However, each class definition points to the URI of the RDF/XML representation via rdfs:seeAlso. Thus, you can fetch all textual definitions and translations by following those rdfs:seeAlso links.
Note 2: This dump file contains only those classes that have been already requested individually. In other words, the number of class definitions available in the dump file grows with the usage of our service.
If you add this link to your bookmarks, you can easily get from any page in the English Wikipedia to the proper class definition on this site.
DBpedia extracts data, e.g. facts and individuals from Wikipedia, and makes those available as a giant RDF representation. This works well for Wikipedia entries that represent individuals, e.g. John F. Kennedy, the city of Paris, Germany as a country, etc. Unfortunately, you cannot use DBpedia identifiers to indicate class membership, because they have a strange semantics. For instance, the DBpedia entry for "Soldering_iron",
http://dbpedia.org/resource/Soldering_ironis defined to be an instance (!!) of the class
http://dbpedia.org/class/yago/ElectronicsWorkToolsThat means, DBpedia says that the entity is an actual soldering iron, instead of being the topic "soldering iron" or a class.
So the following is not possible:
foo:mySolderingIron rdf:type <http://dbpedia.org/resource/Soldering_iron>.Because, that would state that foo:mySolderingIron was an instance of something that is a yago:Soldering_iron.
So DBpedia URIs cannot be used for modeling the type of real-world objects, in particular in the context of the GoodRelations ontology, because
For the majority of the 3.5 million Wikipedia entries, DBpedia offers a very useful representation for the Semantic Web. However, it does not provide a useful RDF representation for the more than 300,000 Wikipedia that describe types of objects, while we urgently need more authoritative class definitions for very specific things.
Note 1: We link from all class definitions in this service to the matching DBpedia resource via rdfs:seeAlso, so it is easy to follow that link if you want to use information from DBpedia in combination with a class definition, e.g. the URIs of images etc.
Note 2: The information in this service comes directly from Wikipedia, which means that new Wikipedia classes or updated texts are available immediately (except for the minor caching interval of 60 minutes).
We don't. This service will also generate class definitions for Wikipedia entries that make for no useful classes. Instead of filtering out valid classes beforehand, we rather watch which identifiers will be used in real-world data. Meaningless class definitions do not harm; meaningless data may.
Unfortunately, this is not possible, because the HTTP protocol does not transmit the hash fragment
(e.g. #Diamond_mandrels in http://en.wikipedia.org/wiki/Grinding_wheel#Diamond_mandrels)
to the remote server, so we cannot know which fragment you are interested in. Since the majority of sections in Wikipedia pages do not define subclasses of the main lemma, it does not make sense to define subclasses for all subsection identifiers by default.
The best solution is establish a new Wikipedia entry in the English(!) Wikipedia for the subsection. If the lemma is important enough to be needed as a class, it should also survive all relevance disputes in the Wikipedia community.
The dump file at
http://www.productontology.org/dump.rdf
contains only those classes that have already been requested from their individual URI at least once, e.g. "Apple" is included only if someone has ever requested the following resource:
http://www.productontology.org/id/Apple
This is necessary because there is no guaranteed way to predict which of the ca. 3.5 million Wikipedia entries make up useful and needed class definitions. We know from our research (Hepp/Siorpaes/Bachlechner, 2007) that between 8.73 % and 19.77 % of the Wikipedia entries make up for useful product classes and you can request a class definition for any Wikipedia lemma that you need to describe your objects, but such cannot be derived automatically from the Wikipedia content. Also, we do not know which classes will be needed and which others are not.
Eventually, we will add filtering techniques so that the dump will only include classes that pass a certain popularity test in RDF datasets.
The semantics of gr:ProductOrService is basically that of a tangible or intangible object on which rights can granted or transferred, so even if social conventions tell us that rain, love, health, longevity, or sex should not be traded, they are not necessarily invalid as subclasses of gr:ProductOrService, because in some environments, it may be perfectly valid to sell rain or seek health by means of RDF and GoodRelations.
First, this is not question but a statement. Second, yes, you are absolutely right: You can request a class definition for John F. Kennedy or Massachusetts in 2010. However, there is absolutely no harm in providing a nonsense class definition, unless someone uses this to annotate an object.
The only classes that we filter out are those for Wikipedia disambiguation pages, since they are mostly irrelevant as classes.
Our approach is grounded in the idea of Human Computation: Instead of identifying valid lemmata beforehand, we rather watch which identifiers will be used in real-world data. Again, meaningless class definitions do not harm; meaningless data may.
First, this is not question but a statement. Second, yes, you are absolutely right: Besides the rdfs:subClassOf axiom, we don't have any formal semantics for each class. Third: Your ontologies likely lack
Fourth: All of our class definitions are valid OWL DL / OWL2 DL, so one can add axioms in complementing graphs with ease.
In order to minimize the load on the Wikipedia API, all requests are cached internally for 72 hours. This means that changes to the English Wikipedia will be available in this service within 72 hours or less if the same entry has been requested before. Classes not requested within the last 72 hours are always guaranteed to be in sync with the latest version in Wikipedia.
The RDF/XML dump file is updated every 12 hours.
The class definition texts are taken from Wikipedia, the free encyclopedia under a Creative Commons Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0) license. Accordingly, all ontology class definitions provided in here are available under the very same license.
Univ.-Prof. Dr. Martin Hepp
E-Business and Web Science Research Group
Chair of General Management and E-Business
Universität der Bundeswehr München
Werner-Heisenberg-Weg 39
D-85579 Neubiberg, Germany
Phone: +49 89 6004-4217
eMail: mhepp(at)computer.org (preferred mode of communication)
Web: http://www.heppnetz.de/
Web: http://www.unibw.de/ebusiness/
Thanks to Stefano Bertolo, Julien Chaumond, Bob Ferris, Kingsley Idehen, Axel Polleres, Andreas Radinger, Alex Stolz, and Giovanni Tummarello for very valuable feedback, and to Katharina Siorpaes and Daniel Bachlechner, who contributed to the initial analysis of the stability of Wikipedia URIs back in 2007. The Social bookmarking icons are from the WPZOOM Social Networking Icon Set, licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
The work on The Product Types Ontology has been supported by the German Federal Ministry of Research (BMBF) by a grant under the KMU Innovativ program as part of the Intelligent Match project (FKZ 01IS10022B).
Hepp, Martin: GoodRelations: An Ontology for Describing Products and Services Offers on the Web, Proceedings of the 16th International Conference on Knowledge Engineering and Knowledge Management (EKAW2008), Acitrezza, Italy, September 29 - October 3, 2008, Springer LNCS, Vol 5268, pp. 332-347.
Hepp, Martin; Siorpaes, Katharina; Bachlechner, Daniel: Harvesting Wiki Consensus: Using Wikipedia Entries as Vocabulary for Knowledge Management, IEEE Internet Computing, Vol. 11, No. 5, pp. 54-65, Sept-Oct 2007.
Last revised: 2024-12-22T00:40:37.561998