How the Dublin Core elements and DCMI terms fit together
The Dublin Core elements began in 1995 as a short list of properties that anyone could use to describe a web resource. The result, the Dublin Core Metadata Element Set, has fifteen elements and lives in the namespace http://purl.org/dc/elements/1.1/, usually abbreviated dc:. It was later published as ISO 15836 and as IETF RFC 5013, and it is still the minimum format every OAI-PMH repository must expose.
Over time the Dublin Core Metadata Initiative (DCMI) built a larger vocabulary around those fifteen elements: the DCMI metadata terms in the dcterms: namespace. It repeats each element with a formal domain and range, adds refinements such as dcterms:rightsHolder and dcterms:isFormatOf, defines classes such as dcterms:MediaType and dcterms:FileFormat, and names encoding schemes like IMT, ISO3166 and RFC5646. When a record needs linked data, the DCMI metadata terms are the better choice; when it needs maximum compatibility, the plain elements still work everywhere.
Which Dublin Core metadata terms matter for file formats
For anyone describing digital files, a handful of terms carry most of the weight. dc:format records the media type, dc:identifier a persistent identifier, dc:date the relevant date in W3CDTF form, and dc:creator, dc:publisher and dc:rights the people and permissions around the file. Language and place values come from code lists: the ISO 639-2 language codes and the ISO 3166-1 country codes.
The pages below are grouped the way the vocabularies are organized. Each one explains a single term: what it means, how its values should look, how it relates to its neighbors and where records typically go wrong.
The fifteen Dublin Core elements at a glance
The table compresses each element to the essentials: what it records, what a typical value looks like, and the mistake that turns up most often in real records. Elements with their own page are linked; the others are covered in the group listings above.
| Element | What it records | Typical value | Common mistake |
|---|---|---|---|
| title | The name given to the resource | Annual report 2024 |
Copying the filename, extension included |
| creator | Who is primarily responsible for the content | Okafor, Ngozi |
Mixing name orders across records |
| subject | The topic, ideally from a controlled list | Digital preservation |
Using it for the genre or the format |
| description | A free-text account of the resource | An abstract or summary | Repeating the title word for word |
| publisher | Who makes the resource available | A university press | Putting the author here as well |
| contributor | Others who contributed to the content | An editor or translator | Listing every helper without a role |
| date | A date in the resource’s lifecycle | 2024-03-15 |
Free-form dates such as March 15th |
| type | The nature or genre | Text, StillImage |
Writing a media type here |
| format | File format, medium or dimensions | application/pdf |
Writing PDF file or a bare extension |
| identifier | An unambiguous reference | A DOI or handle | Using a local path that changes |
| source | A resource this one derives from | The print original of a scan | Confusing it with relation |
| language | Language of the content | en, de, zxx |
Writing English or German as text |
| relation | Any related resource | A URI of a related item | Leaving the kind of relation unstated |
| coverage | Place, period or jurisdiction | Kenya, 1914-1918 |
Repeating the subject in it |
| rights | Rights statements | A license URI | Writing All rights reserved without a holder |
Two of these deserve a second look. Type and format are confused more often than any other pair: type answers “what kind of thing is this?” (a text, an image, a dataset), while format answers “how is it encoded?”. A scanned letter has the type StillImage or Text depending on the cataloging policy, and the format image/tiff. Relation and source overlap in a similar way, with source being the narrower, derivation-specific case.
Simple and qualified Dublin Core
For most of its history, Dublin Core came in two flavors. Simple Dublin Core meant the fifteen elements used on their own, with plain string values. Qualified Dublin Core added element refinements (narrower properties such as a creation date instead of any date) and encoding schemes that said where a value came from.
The flavors made sense when the main use was a record in a database or an XML file. They fit less well once metadata moved to RDF, where every property needs a clear meaning that a machine can reason about. The DCMI Abstract Model, published in the mid-2000s, was the first attempt to describe Dublin Core metadata as a formal model of descriptions, statements and values, so that one record could be expressed in several syntaxes without losing meaning.
In 2008 DCMI assigned formal domains and ranges to the properties in the dcterms: namespace. dcterms:creator, for example, has the range dcterms:Agent, which means its value should be a thing (a person or organization with its own identity), not a string. dcterms:format has the range dcterms:MediaTypeOrExtent, and dcterms:language points to a dcterms:LinguisticSystem. The fifteen properties in the original namespace were left without ranges so that existing records would not suddenly become wrong.
DCMI documentation from 2012 onward describes the fifteen elements in the original namespace as a legacy variant and says implementers may use either the dc: or the dcterms: version depending on what an application requires. In practice, older XML exchange formats keep dc:, while new linked-data work prefers dcterms:, because the ranges let software check that a creator is an agent and a format is a media type.
Reading the DCMI Metadata Terms document
The current reference is a single document, DCMI Metadata Terms, which lists every property, class, datatype and vocabulary encoding scheme DCMI maintains. Each entry gives a URI, a label, a definition, an optional comment and, where they exist, the domain, range and the broader property it refines. The fifteen Dublin Core elements appear twice in it: once in the dcterms: namespace with their formal ranges, and once in a separate section for the legacy dc: namespace.
Three habits make the document easier to use. First, read the definition and the comment together; the comment often carries the practical advice (for format, the recommendation to use a controlled list such as the media type registry). Second, check the range before choosing a value: a range of rdfs:Literal means a string is fine, while a class range means the value should be a resource with its own URI. Third, look at the “Refines” or “Subproperty of” line, since that tells you what a refinement collapses to when a simpler system reads it.
The metadata terms also include a handful of classes that are easy to miss because no element of the original fifteen points to them directly: dcterms:FileFormat, dcterms:Agent, dcterms:LicenseDocument, dcterms:Location, dcterms:PeriodOfTime. Typing a value with one of these classes is often the single change that turns a string-based record into usable linked data. ISO has standardized the same material in two parts, ISO 15836-1 for the core elements and ISO 15836-2 for the properties beyond them.
Refinements and how dumb-down works
A refinement is a property that narrows the meaning of a broader one. dcterms:created, dcterms:issued, dcterms:modified and dcterms:dateSubmitted all refine date; dcterms:alternative refines title; dcterms:abstract and dcterms:tableOfContents refine description; dcterms:extent and dcterms:medium refine format. The relation family is the largest, with pairs such as dcterms:isFormatOf and dcterms:hasFormat, dcterms:isPartOf and dcterms:hasPart, dcterms:isVersionOf and dcterms:hasVersion.
In RDF these are declared as subproperties. That declaration is what makes dumb-down possible: a system that does not understand dcterms:created can treat the statement as a plain dc:date and lose only precision, never meaning. A harvester that knows only simple Dublin Core can still use a qualified record by stripping each refinement back to its parent element.
Dumb-down has limits worth knowing. It drops the encoding scheme as well, so a value tagged as an ISO 639-3 code becomes a bare string. And not every dcterms: property has a parent among the fifteen: dcterms:audience, dcterms:provenance and dcterms:rightsHolder are separate properties, so a crosswalk to simple Dublin Core has to decide what to do with them (usually map them to description or drop them).
Encoding schemes in practice
An encoding scheme tells the reader of a record how to interpret a value. DCMI distinguishes two kinds. A vocabulary encoding scheme names a controlled list: LCSH for subject headings, IMT for internet media types, ISO3166 for country codes, ISO639-3 for languages. A syntax encoding scheme describes a string format: W3CDTF for dates, RFC5646 for language tags, URI for web addresses.
In an RDF record, a vocabulary encoding scheme usually appears through the value itself. A subject is a URI from the scheme, and that URI is declared as a member of the scheme with dcam:memberOf. A syntax encoding scheme appears as the datatype of a literal: "2024-03-15"^^dcterms:W3CDTF. In XML exchange formats, the same information often sits in an xsi:type attribute.
The practical gain is comparability. Two collections that both write fr with RFC5646 can be merged without anyone checking whether “French”, “Français” and “fre” mean the same thing. For media types, the dcterms:MediaType class and the IMT scheme together say that image/png is drawn from the IANA registry, not invented locally.
Application profiles
The Dublin Core standard deliberately makes nothing mandatory. Rules about which properties must appear, how often, and with which value lists live one level up, in a Dublin Core Application Profile (DCAP).
DCMI’s Singapore Framework describes what a full application profile contains: functional requirements, a domain model of the things being described, a description set profile that states the constraints, usage guidelines and encoding syntax guidelines. Few real profiles document every layer, but the framework is a useful checklist when writing one.
A typical institutional repository profile might require title, creator, date issued and identifier; recommend subject, abstract and language; restrict type to a short list; and demand that dates follow W3CDTF and languages follow ISO 639. A cultural-heritage profile for photographs would weigh coverage, rights and source far more heavily. Both use the same Dublin Core properties, and the profile is what makes their records predictable.
Profiles also mix vocabularies. Almost every working profile borrows properties from outside DCMI, which is where the next section comes in.
How Dublin Core sits beside other vocabularies
Dublin Core describes resources at a general level. Other vocabularies cover what it leaves out, and a well-built record uses each for what it does best.
FOAF describes people and agents: names, nicknames, home pages, depictions. When dcterms:creator points to an agent, that agent’s own description usually uses FOAF properties such as foaf:name.
SKOS is the standard way to publish thesauri and controlled vocabularies as linked data. Subject terms used as values of dcterms:subject are often SKOS concepts, with preferred labels, alternative labels and notes.
schema.org is aimed at search engines and web markup. It overlaps with Dublin Core in many places (name, author, datePublished, encodingFormat) and is the usual choice for metadata embedded in web pages, while Dublin Core stays common in repositories and library systems.
PREMIS covers preservation metadata: fixity, events, agents, rights and the technical environment needed to render a file. Its format information can include a format registry name and key, such as a PRONOM identifier, which goes well beyond what dc:format can say.
MODS, maintained by the Library of Congress, is a richer bibliographic schema than simple Dublin Core, with structured names, titles and subjects. Records often move between MODS and Dublin Core through published crosswalks.
METS is a container. It wraps descriptive metadata (Dublin Core or MODS), administrative and preservation metadata (often PREMIS) and a structural map of the files in a digital object into one XML document.
Serializations
The same Dublin Core description can be written in several syntaxes. Each has a place.
RDF/XML and Turtle
RDF/XML was the first standard serialization of RDF and remains common in older linked-data publications. It is verbose and hard to read by hand. Turtle expresses the same triples far more compactly, with prefixes declared once at the top:
@prefix dcterms: <http://purl.org/dc/terms/> .
<https://example.org/item/42>
dcterms:title "Annual report 2024"@en ;
dcterms:created "2024-03-15"^^dcterms:W3CDTF ;
dcterms:format <https://www.iana.org/assignments/media-types/application/pdf> ;
dcterms:language <http://id.loc.gov/vocabulary/iso639-2/eng> .
JSON-LD
JSON-LD carries RDF inside ordinary JSON, using a context to map short keys to full URIs. It is the format most web developers meet first, and it lets a record that looks like plain JSON still be read as linked data by any RDF tool.
HTML meta elements
An older convention, documented in RFC 2731, embeds Dublin Core in the head of a web page. A link element declares the schema (rel="schema.DC" pointing to the elements namespace), and meta elements carry the values with a DC. prefix: <meta name="DC.title" content="...">, <meta name="DC.language" content="en">. A schema.DCTERMS declaration does the same for dcterms: properties. The convention survives in many content management systems and journal platforms.
oai_dc
The oai_dc format is the XML schema that the OAI-PMH protocol requires every repository to support. It permits only the fifteen unqualified elements, each repeatable and each optional, with string values. That restriction is the reason dumb-down matters so much in practice: a repository with rich qualified records still has to export a simple version through oai_dc, and the quality of that export depends on how carefully its refinements map back to the fifteen elements. The guide to writing Dublin Core records shows how to keep the simple version useful.
Language values in oai_dc are a common weak spot. The schema accepts any string, so records arrive with English, eng, en and en-US side by side. Choosing one form in the profile and checking it at export, against the codes on the language code type page, removes most of the clean-up work a harvester would otherwise face.