Skip to content
Guide · 10 min read

Writing Dublin Core metadata records: a practical guide, with examples

Dublin Core is short enough to learn in an afternoon and loose enough to be written badly for years. Good records come from a handful of habits: one resource per record, one value per statement, controlled vocabularies wherever they exist, and dates and formats in a form a machine can read.

Published Formatory editorial team
Fifteen glass tiles in a floating grid, some lit from within and joined by thin lines

Most Dublin Core records go wrong in small ways. A date written as “c. 1970s” in one record and “1974” in the next. A format given as “PDF document” where application/pdf was expected. Three authors packed into one creator field with semicolons. None of this breaks the record on its own, and all of it breaks the search interface that later tries to sort, filter or merge thousands of records. This guide covers how to write Dublin Core metadata records that hold up when someone else’s software reads them.

Simple and qualified Dublin Core

The Dublin Core Metadata Element Set has fifteen elements: title, creator, subject, description, publisher, contributor, date, type, format, identifier, source, language, relation, coverage and rights. It is published as ISO 15836 and as ANSI/NISO Z39.85. Every element is optional, and every element can repeat.

Simple Dublin Core uses only those fifteen elements, with plain text values. It is easy to produce and easy to harvest, which is why it became the baseline for exchange between repositories.

Qualified Dublin Core adds two kinds of precision. Element refinements narrow the meaning of an element: dcterms:created, dcterms:issued and dcterms:modified are kinds of date; dcterms:abstract and dcterms:tableOfContents are kinds of description; dcterms:spatial and dcterms:temporal split coverage. Encoding schemes state the source or syntax of a value: a date in W3CDTF, a subject from LCSH, a language code from ISO 639-2.

The two are linked by what DCMI calls the dumb-down principle. A system that does not understand a refinement should be able to ignore it and treat the value as the broader element, so dcterms:created "1968" still makes sense as a date.

dc: and dcterms:

The fifteen original elements live in the namespace http://purl.org/dc/elements/1.1/, usually prefixed dc:. DCMI Metadata Terms, in http://purl.org/dc/terms/ and usually prefixed dcterms:, contains all fifteen again, plus the refinements, plus classes such as dcterms:Agent, dcterms:MediaType and dcterms:LinguisticSystem.

The difference is formal ranges. dc:creator accepts anything; dcterms:creator expects an agent, which suits a URI pointing to an authority record. dc:language accepts a string; dcterms:language expects a linguistic system. For new records published as linked data, dcterms: is the usual choice. For OAI-PMH harvesting and for systems built around simple Dublin Core, dc: remains standard. Mixing them in one record is allowed and common, as long as the record does not say the same thing twice in both namespaces.

Choosing a syntax

Dublin Core is a vocabulary, not a file format, so the same record can be written several ways. The choice usually follows the system that will read it.

  • XML with the DCMI schemas or the oai_dc schema is what most repository software exchanges, and what OAI-PMH harvesters expect.
  • RDF/XML and Turtle express the record as RDF statements about a URI. Turtle is far easier to read and write by hand; RDF/XML survives in older triple stores and tools.
  • JSON-LD suits web applications and is the syntax search engines read most readily, often alongside schema.org terms.
  • HTML meta tags follow a DCMI convention that declares the namespace with <link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"> and then writes elements as <meta name="DC.title" content="...">. They are simple to add to a page but carry only flat values.

Whatever the syntax, the content decisions below stay the same. A record with a vague date and a free-text format is just as weak in JSON-LD as in XML.

A worked record: a digitized report

The first example is a fictional printed report from 1968, scanned by a city archive in 2024. The record describes the digital copy, the PDF, and points back to the printed original.

<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:dcterms="http://purl.org/dc/terms/">
  <rdf:Description rdf:about="https://example.org/archive/reports/harbor-wall-1968.pdf">
    <dc:title>Report on the condition of the harbor wall</dc:title>
    <dc:creator>Marsh, Edith</dc:creator>
    <dc:creator>Example City Engineering Department</dc:creator>
    <dc:subject>Harbors</dc:subject>
    <dc:subject>Sea walls</dc:subject>
    <dc:description>Survey of cracking and erosion along the north harbor wall, with eleven photographs and two folded plans.</dc:description>
    <dc:publisher>Example City Archive</dc:publisher>
    <dcterms:created>1968-09</dcterms:created>
    <dcterms:issued>2024-03-11</dcterms:issued>
    <dc:type>Text</dc:type>
    <dc:format>application/pdf</dc:format>
    <dcterms:extent>48 pages</dcterms:extent>
    <dc:identifier>https://example.org/archive/reports/harbor-wall-1968.pdf</dc:identifier>
    <dcterms:isFormatOf rdf:resource="https://example.org/archive/catalog/item/R-1968-114"/>
    <dc:language>eng</dc:language>
    <dcterms:spatial>Example City (harbor district)</dcterms:spatial>
    <dc:rights>Digitized copy available for non-commercial use with attribution.</dc:rights>
  </rdf:Description>
</rdf:RDF>

A few decisions worth noting. dcterms:created holds the date of the original report, and dcterms:issued the date the digital copy was made public; plain dc:date would have forced a choice between them. The publisher is the archive that made the PDF available, not the department that wrote the report. dcterms:isFormatOf points to the catalog record of the printed copy, which keeps the one-to-one principle intact: this record describes the PDF, the other describes the paper.

A worked record: a born-digital dataset

The second example is a fictional dataset of river temperature readings, published as a CSV file, written in Turtle with dcterms: throughout.

@prefix dcterms: <http://purl.org/dc/terms/> .
@prefix dcmitype: <http://purl.org/dc/dcmitype/> .
@prefix dcam: <http://purl.org/dc/dcam/> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

<https://example.org/data/river-temperature-2023-2025>
    dcterms:title "River temperature readings, Example River, 2023–2025"@en ;
    dcterms:creator <https://example.org/people/j-okoro> ;
    dcterms:publisher <https://example.org/org/water-lab> ;
    dcterms:subject [ rdfs:label "Water temperature" ; dcam:memberOf dcterms:LCSH ] ;
    dcterms:description "Hourly water temperature from six fixed sensors, in degrees Celsius."@en ;
    dcterms:type dcmitype:Dataset ;
    dcterms:format <https://www.iana.org/assignments/media-types/text/csv> ;
    dcterms:created "2025-01-15"^^dcterms:W3CDTF ;
    dcterms:temporal "2023-01-01/2025-12-31" ;
    dcterms:language <http://id.loc.gov/vocabulary/iso639-2/eng> ;
    dcterms:identifier "https://example.org/data/river-temperature-2023-2025" ;
    dcterms:license <https://creativecommons.org/licenses/by/4.0/> .

Here the creator and publisher are URIs, which a linked-data consumer can follow to a description of the person and the lab. The type comes from the DCMI Type Vocabulary as a URI. The license uses dcterms:license, a refinement of rights, with the license’s own URI, which machines can interpret far more reliably than a sentence. The subject is marked as a member of LCSH with dcam:memberOf, the pattern DCMI documents for vocabulary encoding schemes.

Element-by-element advice

Title. Transcribe the title as it appears on the resource, keeping its wording and its subtitle; normalizing capitalization is a local choice, rewording is not. Supply a devised title only when there is none, keep it plainly descriptive, and say so in a note. An untitled photograph might become “Harbor wall, north section, looking east”, which tells a reader what to expect without pretending to be the photographer’s title. Alternative titles go in dcterms:alternative. See dcterms:title.

Creator and contributor. One value per entity, in the order given on the resource, with a consistent name form (inverted personal names are the library convention). Editors, translators and illustrators are usually contributors. The dc:creator page covers the edge cases.

Subject. Prefer a controlled vocabulary. LCSH is the most common in libraries; subject-specific thesauri work better in many fields. Repeat the element for each heading. The qualified form is dcterms:subject.

Description. A short, factual account of what the resource contains: scope, notable parts, physical features that matter (photographs, maps, missing pages). It should add something the title does not; a description that repeats the title in other words gives a search engine nothing new. Use dcterms:abstract for an author’s abstract and keep it verbatim. See dcterms:description.

Publisher. The entity that made the resource available. For a digitized item, that is usually the digitizing institution, not the original publisher of the print. See dc:publisher.

Date. W3CDTF (YYYY, YYYY-MM, YYYY-MM-DD) and no false precision. In qualified records, use dcterms:created, dcterms:issued or dcterms:modified to say which date is meant. See dc:date.

Type. A DCMI Type term (Text, StillImage, Dataset, Sound, MovingImage, Software, Collection and others), optionally followed by local genre terms. See dc:type.

Format. A registered IANA media type such as application/pdf or image/tiff, from the IMT scheme. Extent and physical medium go in dcterms:extent and dcterms:medium. See dc:format and, for working out the media type of a file, the file format identification guide.

Identifier. A persistent, globally unique identifier where one exists: a DOI, a handle, an ARK or a stable URL. Local shelf marks can appear as further values. An identifier describes the resource of the record itself, so a digitized copy does not take the ISBN of the printed book; that belongs to the record of the print. See dc:identifier.

Source. The resource this one was derived from, best given as an identifier. For a digitized copy, dcterms:isFormatOf is often the more precise relation. See dc:source.

Language. A code from ISO 639-2 (eng, fra, deu) or an RFC 5646 language tag (en, en-GB, pt-BR). See dc:language and the language code list.

Relation. Links to related resources by identifier. The refinements (isPartOf, hasVersion, references and others) say what kind of relation it is. See dcterms:relation.

Coverage. Place or time the resource is about. In qualified records, dcterms:spatial and dcterms:temporal separate the two. Country codes from ISO 3166 and gazetteer URIs are more reliable than free text; see the country code list.

Rights. A rights statement, ideally as a URI (a Creative Commons license, a RightsStatements.org statement). Use dcterms:license for licenses and dcterms:rightsHolder for the holder. See dc:rights.

Repeating values or combining them

The rule is simple: one value per statement, repeated as often as needed. Two subjects are two dc:subject elements, not one element reading “Harbors; Sea walls”. Combined strings look harmless in a display but break faceted search, sorting and deduplication, because every downstream system has to guess at the separator.

The exception is a value that is genuinely one thing with internal structure: a title with a subtitle, a corporate name with subdivisions, a date range. A period written as an ISO 8601 interval with a slash, as in the dataset example, is one temporal value.

Repetition also handles languages. A report with a title in English and in French gets two title statements, each tagged with its language (xml:lang="fr" in XML, "..."@fr in Turtle), not one title joining both with a slash. Display software can then pick the title that matches the reader’s interface, and an aggregator that indexes only one language still gets a clean value.

Order is the one thing repetition does not guarantee. RDF treats repeated statements as an unordered set, so a creator sequence that matters (the order of authors on a paper, for instance) survives reliably only in XML or in a system that stores the order explicitly. Where author order carries meaning, it is worth checking that the export keeps it.

Encoding schemes in practice

Encoding schemes do more for interoperability than any other part of qualified Dublin Core. The ones in widest use:

Element Encoding scheme Example value
Date W3CDTF (ISO 8601 profile) 1968-09
Format IMT (IANA media types) application/pdf
Language ISO 639-2, RFC 5646 eng, en-GB
Coverage (place) ISO 3166 DE, BR
Subject LCSH Sea walls

In XML and RDF/XML records without linked-data support, schemes are often stated with an xsi:type attribute (in the DCMI XML schemas) or a datatype. In RDF, the cleanest approach is to use the URI the vocabulary itself publishes, as the dataset example does for language and type.

Application profiles

Dublin Core sets no requirements of its own, so every project that needs consistency writes them down in an application profile. A profile lists the properties in use (Dublin Core plus anything borrowed from other vocabularies), marks them required, recommended or optional, sets how often each may repeat, and names the vocabularies their values must come from. DCMI’s Singapore Framework describes how such profiles should be documented. DCAT, used by government data portals, is a well-known profile that builds heavily on dcterms:.

A short profile, even a two-page table, prevents most of the problems this page opened with. Without one, every cataloger makes reasonable but different decisions.

OAI-PMH and oai_dc

The Open Archives Initiative Protocol for Metadata Harvesting requires every repository to expose records in oai_dc, a simple Dublin Core format with its own XML schema. Records sit inside an <oai_dc:dc> wrapper and use only the fifteen dc: elements, with no refinements and no encoding scheme attributes.

That makes oai_dc a lossy view of a qualified record. dcterms:created and dcterms:issued both become dc:date; dcterms:isFormatOf becomes a dc:relation or dc:source. When a repository maps its rich records down, it should do so deliberately, choosing which date appears first, and keeping identifiers as resolvable URLs so that harvesters can link back.

Common mistakes

  • Describing two resources in one record, typically the original and its digital copy, with two dates and two publishers jumbled together.
  • Free-text formats (“PDF document”, “jpg”) where a media type was expected.
  • Mixed date forms across a collection, or a digitization date presented as the creation date.
  • Local genre terms in dc:type with no DCMI Type term alongside them.
  • Packed values: several creators or subjects in one field.
  • HTML or wiki markup inside values, which shows up literally in other systems.
  • Identifiers that do not resolve, such as internal database keys with no public URL.
  • Rights as a vague sentence where a license URI exists.

The mistake that costs the most to fix later is the first one, because separating two resources means going back to the source material for every affected record.

Questions and answers

What is a Dublin Core metadata record?

A Dublin Core metadata record is a set of statements describing one resource with the Dublin Core vocabulary: its title, creator, date, format, identifier and so on. It can be written in XML, RDF/XML, Turtle, JSON-LD or HTML meta tags; the vocabulary stays the same across all of them.

What is the difference between simple and qualified Dublin Core?

Simple Dublin Core uses only the fifteen original elements with plain values. Qualified Dublin Core adds refinements such as dcterms:created or dcterms:abstract and encoding schemes that state where a value comes from, such as W3CDTF for dates or LCSH for subjects.

Should a record use dc: or dcterms:?

For new linked-data records, the dcterms: namespace is generally preferred because its properties have formal ranges and it includes all fifteen elements plus the refinements. The dc: namespace remains standard for OAI-PMH oai_dc records and for systems that expect simple Dublin Core.

Are all Dublin Core elements required?

No. In Dublin Core itself every element is optional and repeatable. Requirements come from application profiles: a repository or aggregator may make title, creator, date and rights mandatory for its own records, and may limit which values are allowed.

How should dates be written in Dublin Core?

Use the W3CDTF profile of ISO 8601: 2024, 2024-05 or 2024-05-17, with no more precision than is actually known. Free-text dates such as "spring 1968" are hard for systems to sort; a qualified record can add them in a note while keeping a machine-readable value.

What should go in dc:type?

A term from the DCMI Type Vocabulary, such as Text, StillImage, Dataset, Sound or MovingImage. Genre terms such as "report" or "letter" can be added as further values, but the DCMI term keeps the record interoperable with aggregators.

Can one record describe both an original and its digital copy?

Not cleanly. The one-to-one principle says each record describes one resource. A digitized report gets its own record, and the printed original is either described in a separate record or referenced through dcterms:isFormatOf or dc:source.

What is oai_dc?

oai_dc is the simple Dublin Core metadata format every OAI-PMH repository must support. Records are wrapped in an <oai_dc:dc> element and use only the fifteen dc: elements, which makes it a lowest common denominator for harvesting across repositories.

How should multiple creators be recorded?

Repeat the element, one value per creator, in the order the resource itself gives, using the same name form throughout the collection. Avoid packing several names into one value with semicolons; aggregators split such strings unreliably. See dc:creator for name forms.

What is an application profile?

An application profile is a documented set of rules for a specific community or system: which Dublin Core and other properties are used, which are required, how often they may repeat, and which vocabularies and encoding schemes their values must come from. It is what turns Dublin Core into a consistent local standard.

More guides

All guides