The Semantic Web Explained: From Linked Data to Knowledge Graphs

Q: What is the semantic web in simple terms?

The semantic web is a way of publishing data on the web so that software can read what it means, not only how it looks. Each thing (a person, a place, a product) gets a web address, facts about it are written as subject-predicate-object statements, and those statements link to other data. It is the foundation of most modern knowledge graphs.

Q: Is the semantic web the same as Web 3.0?

Around 2006, "Web 3.0" was sometimes used as a label for the semantic web. Since about 2020, "web3" usually refers to blockchain-based decentralized applications and cryptocurrency, which have no technical connection to RDF or linked data. When reading older material, "Web 3.0" probably means the semantic web; in current usage, it probably does not.

The semantic web is an extension of the World Wide Web, proposed by Tim Berners-Lee and standardized by the W3C, in which data is published in machine-readable form so that software can interpret the meaning of web content rather than only display it. It is built on a stack of open standards (RDF, RDFS, OWL, SPARQL, SHACL, and JSON-LD) that describe things, their properties, and the relationships between them. Most of what is now called a knowledge graph uses Semantic Web technologies directly or descends from them.

The original vision

In May 2001, Scientific American published “The Semantic Web” by Tim Berners-Lee, James Hendler, and Ora Lassila. The article described a web where documents carried structured meaning that software agents could read, so that a program could, for example, find a clinic, check its opening hours against a person’s calendar, and book an appointment without a human interpreting each page. The core proposal was that web content should be expressed as statements about things, using shared vocabularies, with each thing identified by a URI.

The vision had two parts. The first was a data architecture: identify things with URIs, describe them with triples, share vocabularies, and link across sites. The second was an application vision: autonomous agents acting on that data on a user’s behalf. The first part largely succeeded. The second did not arrive in the form the article predicted.

The semantic web stack, layer by layer

The W3C’s design is usually drawn as a layered stack, sometimes called the “semantic web layer cake.” Each layer depends on the ones below it.

Layer	Standard	What it provides
Identifiers and characters	IRIs, Unicode	A global naming scheme. Every thing, class, and property is named by an IRI (an internationalized URI).
Syntax	XML (originally); later Turtle, JSON-LD, N-Triples	A serialization to write data down. XML was the first RDF syntax; it is now rarely the preferred one.
Data model	RDF	The triple: subject, predicate, object. Every fact is one triple; a set of triples is a graph.
Basic vocabulary	RDFS (RDF Schema)	Classes, subclasses, properties, domains, ranges, and human-readable labels (`rdfs:label`).
Ontology	OWL	Richer logic: class equivalence, disjointness, cardinality, inverse and transitive properties, reasoning.
Query	SPARQL	A query language and protocol for RDF graphs, comparable to SQL for relational data.
Validation	SHACL	Shapes that state what a valid graph must look like, used to check data quality.
Web syntax	JSON-LD	A JSON serialization of RDF that ordinary web developers could embed in HTML pages.

JSON-LD deserves particular attention. Earlier RDF syntaxes were unfamiliar to most web developers. JSON-LD, a W3C Recommendation since 2014 with version 1.1 following in 2020, expressed the same triples in plain JSON. When Google adopted it as its recommended format for structured data, semantic web data began appearing on ordinary web pages written by people who had never read an RDF specification.

A minimal example in Turtle

The following Turtle snippet uses two of the most common properties in the stack. rdf:type (abbreviated a in Turtle) states which class a thing belongs to; rdfs:label gives it a human-readable name.

@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix wd:   <http://www.wikidata.org/entity/> .
@prefix schema: <https://schema.org/> .

wd:Q243 rdf:type schema:LandmarksOrHistoricalBuildings ;
        rdfs:label "Eiffel Tower"@en ,
                   "Tour Eiffel"@fr ;
        schema:location wd:Q90 .

wd:Q90  a schema:City ;
        rdfs:label "Paris"@en .

wd:Q243 is the Wikidata IRI for the Eiffel Tower. The first triple says it is an instance of a schema.org class, the label triples attach names in two languages, and the last triple links it to wd:Q90, the Wikidata IRI for Paris. Anyone who dereferences those IRIs gets more data about the same entities, which is the linking mechanism that gives the semantic web its name. The mechanics of the triple itself are covered in RDF triples: subject, predicate, object.

What succeeded

Judged against the 2001 article, the semantic web is often described as a failure. Compared with today’s data infrastructure, several of its components are among the most widely deployed standards on the web.

schema.org. Launched in 2011 by Google, Microsoft, Yahoo, and later Yandex, schema.org is a shared RDFS-style vocabulary of several hundred types, embedded in a large fraction of all web pages via JSON-LD, Microdata, and RDFa. It succeeded where earlier vocabularies did not because search engines gave publishers a direct incentive to use it.

Wikidata. Launched by Wikimedia in 2012, Wikidata is a collaboratively edited knowledge base with over 100 million items, each identified by a Q-ID (Q937 is Albert Einstein). It publishes its content as RDF and exposes a public SPARQL endpoint, the Wikidata Query Service. It is the largest openly licensed knowledge graph and the central hub of the linked open data cloud.

Linked open data. The linked data principles, published by Berners-Lee in 2006, gave the semantic web a practical publishing recipe. DBpedia, GeoNames, the Library of Congress, Europeana, and hundreds of national libraries, statistical offices, and research institutions publish RDF that links across datasets.

Google Knowledge Graph. Announced in May 2012 with the phrase “things, not strings,” the Google Knowledge Graph drew on Freebase (an RDF-based knowledge base Google acquired in 2010) and on schema.org markup from the open web. It is proprietary and has no SPARQL endpoint, but its data model, shared entity identifiers, and reliance on publisher structured data come directly from semantic web practice.

What stalled

The agent-driven web. The 2001 article’s central scenario, autonomous software agents negotiating across sites on a user’s behalf, did not materialize through RDF. Obstacles included the difficulty of getting publishers to describe their data in depth, the lack of a business model for doing so, and the brittleness of logic-based reasoning against incomplete, inconsistent data.

Universal OWL adoption. OWL, particularly its more expressive profiles, requires formal logic training to use well, and reasoners are slow on large graphs. Most public web data uses RDFS-level vocabularies (schema.org, Dublin Core, SKOS) and never touches OWL’s advanced features. OWL is common in life sciences and enterprise ontologies (the Gene Ontology, SNOMED CT) and rare on the open web.

The name itself. By the early 2010s, “semantic web” carried connotations of unfinished academic ambition. Practitioners increasingly described the same technology as “linked data” and then as “knowledge graphs”.

Semantic web vs knowledge graph as terms

The two terms overlap heavily but are not synonyms. “Semantic web” names a set of W3C standards and the vision of applying them across the whole web. “Knowledge graph” names a data structure: a graph of entities and relationships with an explicit schema, whether or not it is built with W3C standards or published on the web.

Every RDF dataset published according to linked data principles is a knowledge graph. Not every knowledge graph uses semantic web technology: Neo4j and other labeled property graph (LPG) databases hold knowledge graphs without RDF, IRIs, or SPARQL. The term “knowledge graph” became dominant after Google’s 2012 announcement because it described the outcome (a useful graph of facts) rather than the method, and because it was neutral between the RDF and property-graph camps. See knowledge graph vs graph database.

“Web 3.0” and the naming confusion with web3

Around 2006, several writers, including Berners-Lee in interviews, used “Web 3.0” as a shorthand for the semantic web, extending the “Web 2.0” label popularized for the social, user-generated web. The phrase never settled into common use for RDF and linked data. From roughly 2020 onward, “web3” (usually lowercase) came to mean a proposed decentralized web built on blockchains, cryptocurrencies, and token ownership. The two ideas share a word and nothing technical. Searches for “web 3.0 semantic web” typically come from readers who have encountered the older usage.

For developers

The practical entry point to the stack is the middle, not the top. Learn the RDF data model, write a few triples in Turtle, and run SPARQL queries against the Wikidata Query Service before reading about OWL. rdflib (Python), Apache Jena (Java), and RDF4J handle parsing, serialization, and querying. Triple stores such as GraphDB, Blazegraph, Stardog, Amazon Neptune, and Virtuoso provide storage; see graph databases.

Reasoning and validation are separate concerns. RDFS and OWL reasoning infers new triples (if ex:Cat rdfs:subClassOf ex:Animal and ex:Felix a ex:Cat, a reasoner concludes ex:Felix a ex:Animal). SHACL does not infer; it checks that data conforms to shapes and reports violations. Most production systems use SHACL for data quality and use reasoning sparingly. JSON-LD is the bridge to non-RDF systems: any JSON API becomes RDF-compatible by adding a @context. For building a graph from scratch, see knowledge graph in Python.

For SEOs

Every piece of schema.org JSON-LD on a web page is semantic web data. Search engines parse it into triples, reconcile the entities against their own knowledge graphs, and use the result for rich results and knowledge panels. An SEO who writes Organization markup with a sameAs array pointing to a Wikidata Q-ID is doing what the 2001 article described: identifying a thing by a shared URI and linking it to other data about it.

Two consequences follow. The vocabulary matters more than the syntax: JSON-LD, Microdata, and RDFa all produce the same triples, so choose the one that is easiest to maintain (Google recommends JSON-LD). And identifiers matter: @id, sameAs, and consistent entity naming across pages let search engines merge statements about the same entity. See entity SEO and sameAs schema for more on this.

Common misconceptions

“Semantic web means AI understands web pages.” The semantic web makes data explicit so software doesn’t need to understand natural language. Modern systems combine both, using NLP to extract entities and RDF to store and link them; see entity linking, NER, and extraction.

“You need OWL to build a knowledge graph.” Most public knowledge graphs use RDFS-level vocabularies. OWL is optional and often unnecessary.

FAQ

What is the semantic web in simple terms?

The semantic web is a way to publish data on the web so software can read what it means, not just how it looks. Each thing (a person, a place, a product) gets a web address, facts about it are written as subject-predicate-object statements, and those statements link to other data. It is the foundation of most modern knowledge graphs.

Is the semantic web the same as Web 3.0?

Around 2006, “Web 3.0” was sometimes used to label the semantic web. Since about 2020, “web3” usually refers to blockchain-based decentralized applications and cryptocurrency, which have no technical connection to RDF or linked data. When reading older material, “Web 3.0” probably means the semantic web; in current usage, it probably does not.

What are the main semantic web technologies?

The core standards are RDF (the triple data model), RDFS and OWL (vocabularies and ontologies), SPARQL (query language), SHACL (validation), and serialization formats including Turtle and JSON-LD. Shared vocabularies such as schema.org, SKOS, and Dublin Core are built on these. All are published by the W3C or maintained as open community standards.

Did the semantic web succeed or fail?

Both. The 2001 vision of autonomous agents acting on structured web data did not arrive through RDF. But the standards produced schema.org markup on a large share of web pages, Wikidata with over 100 million items, the linked open data cloud, and the data model behind the Google Knowledge Graph. The technology succeeded; knowledge graphs and search replaced the original application story.

Sources and further reading

Berners-Lee, Hendler, Lassila, “The Semantic Web,” Scientific American, May 2001: https://www.scientificamerican.com/article/the-semantic-web/
W3C Semantic Web activity overview: https://www.w3.org/2001/sw/
RDF 1.1 Primer (W3C): https://www.w3.org/TR/rdf11-primer/
OWL 2 Web Ontology Language Primer (W3C): https://www.w3.org/TR/owl2-primer/
JSON-LD 1.1 (W3C Recommendation, 2020): https://www.w3.org/TR/json-ld11/
schema.org: https://schema.org/
Google Search Central, “Introduction to structured data markup”: https://developers.google.com/search/docs/appearance/structured-data/intro-structured-data