Examples
Worked examples
- Is an instance
The DataCite Metadata Schema's canonical, normative serialization is an XML Schema (XSD); the same schema's fields are also returned and accepted as JSON by the DataCite REST API — one schema, two formats, chosen based on what the consuming system needs.
- Is an instance
Dublin Core metadata is classically harvested as XML via the OAI-PMH protocol, but the identical fifteen-element vocabulary can equally be published as RDF/Turtle or JSON-LD when the same records are exposed as linked data instead of a harvestable feed.
- Is an instance
schema.org's Dataset vocabulary — the schema Google Dataset Search and other engines read — is typically embedded in a page as JSON-LD, Google's own recommended format for structured data, but the identical vocabulary can also be marked up with Microdata or RDFa directly in the HTML.
- Is an instance
The RDA DMP Common Standard, a schema for describing data management plans, has a JSON-LD serialization (RDA-DMP-JSON-LD) that machine-actionable DMP tools exchange over APIs — the schema defines what a 'DMP' record contains; the JSON-LD format defines how that record is written on the wire.
Counter-examples
Looks similar, but isn't
- Not an instance
PROV-O is not a format — it is an RDF vocabulary (a schema: Entity, Activity, Agent, and the relations between them) that must itself be serialized in some concrete format — RDF/XML, Turtle, or JSON-LD — before it can be written to a file or sent over HTTP. Calling PROV-O 'a format' describes the wrong layer.
- Not an instance
Conversely, 'XML' by itself is not a schema — it is a generic markup format with no fixed field set of its own. JATS XML, DataCite's XML serialization, and MODS are three completely unrelated schemas that all happen to choose XML as their format; knowing a document 'is XML' says nothing about which fields it contains until you also know which schema it conforms to.
Editorial commentary
Metadata format (or serialization format) is the syntax used to encode metadata as bytes on disk or on the wire — XML, JSON, RDF/Turtle, and YAML are the formats most often seen in research metadata work. It is a distinct layer from a metadata schema, and the two get conflated often enough in everyday conversation that it is worth stating the distinction plainly.
Schema vs. format: two different questions
A schema answers which fields exist and what they mean — Dublin Core’s fifteen elements, DataCite’s mandatory Identifier/Creator/Title/Publisher/PublicationYear/ResourceType properties, Darwin Core’s biodiversity-occurrence terms. A format answers how those field-value pairs get physically written down so a parser on the other end can read them back. Guidance on picking between competing field sets — covered in How to Choose a Metadata Schema for a Dataset — is a schema decision. Format is the separate, downstream decision of how the chosen schema’s output actually gets encoded for a repository, API, or harvesting protocol to consume.
The major formats in research metadata
- XML — still the dominant format for repository interoperability, largely because OAI-PMH, the long-standing repository-harvesting protocol, mandates XML-encoded records, and because many established schemas (JATS XML for journal articles, DataCite’s own canonical serialization) define an XML Schema (XSD) as their normative structure.
- JSON — the default for modern REST APIs, including DataCite’s own API, because it is lighter-weight and maps directly onto the objects most application code already works with.
- RDF and its serializations (Turtle, RDF/XML, N-Triples) — used when metadata needs to function as linked data: statements as subject-predicate-object triples that can be queried across sources (see RDF triple store, SPARQL endpoint). Turtle is the human-readable RDF serialization; RDF/XML wraps the same triples in XML syntax.
- JSON-LD — a hybrid: ordinary JSON that also carries an RDF/linked-data interpretation via an embedded
@context. This is why JSON-LD shows up specifically for schema.org structured data, PROV-O provenance records, and the RDA DMP Common Standard’s RDA-JSON-LD serialization — it gets the developer ergonomics of JSON with the graph semantics of RDF. - YAML — less common for interchange between systems, but frequently used for human-authored metadata configuration, such as front-matter blocks or
codemeta.json-adjacent local config files, where hand-editing readability matters more than wire efficiency.
Why format choice affects interoperability
Two systems that agree perfectly on schema can still fail to interoperate if they disagree on format — a harvester built to parse XML cannot ingest an RDF/Turtle feed of the identical fields without a conversion step, even though every field means exactly the same thing in both. This is why interoperability specifications frequently pin down format as well as schema: OAI-PMH mandates XML regardless of which schema (Dublin Core, MODS, or another) is being harvested; the DataCite REST API defaults to JSON while still publishing the equivalent XML for systems that need it. When evaluating whether two metadata sources will interoperate, checking that a repository’s declared schema matches is necessary but not sufficient — confirm the format matches too, or that a documented, lossless crosswalk between formats exists.
Related terms
See also Core metadata, DataCite metadata schema, Dublin Core, PROV-O (Provenance Ontology), OAI-PMH, and DMP RDA-JSON-LD, and the guide How to Choose a Metadata Schema for a Dataset.
Machine-readable encodings
Use in your systems
<role vocab="credit"
vocab-identifier="https://casrai.org/dictionary/"
vocab-term="Metadata Format"
vocab-term-identifier="https://casrai.org/dictionary/term/metadata-format" />{
"@context": "https://schema.org",
"@type": "DefinedTerm",
"@id": "https://casrai.org/dictionary/term/metadata-format",
"name": "Metadata Format",
"identifier": "https://casrai.org/dictionary/term/metadata-format",
"description": "A metadata format (also called a serialization format) is the concrete syntactic encoding used to write metadata values out as a machine-readable byte stream for storage, exchange, or transmission — for example XML, JSON, RDF/Turtle, or YAML. It answers 'how is this metadata physically written down,' which is a separate question from what a metadata schema answers: 'which fields exist and what do they mean.' A schema (Dublin Core, DataCite, Darwin Core, PROV-O) defines the field set and semantics; a format defines the byte-level syntax those fields get poured into. The same schema is routinely available in more than one format, and the same format is routinely used to carry many unrelated schemas — so 'metadata format' and 'metadata schema' are not interchangeable, even though the two terms get conflated constantly in casual usage.",
"inDefinedTermSet": "https://casrai.org/dictionary/domain/data-infrastructure#set",
"url": "https://casrai.org/dictionary/term/metadata-format",
"sameAs": [],
"license": "https://creativecommons.org/licenses/by/4.0/",
"publisher": {
"@id": "https://casrai.org/#organization"
},
"dateModified": "2026-07-18T06:30:53",
"inLanguage": "en"
}
