RDF 1.2 N-Triples

N-Triples is a line-based, plain text format for encoding an RDF graph.

RDF 1.2 N-Triples introduces triple terms as a fourth kind of RDF term which can be used as the subject or object of another triple, making it possible to make statements about other statements. RDF 1.2 N-Triples also adds support for directional language-tagged strings.

This document is part of the RDF 1.2 document suite. The N-Triples format is a line-based RDF syntax based on a subset of Turtle [[RDF12-TURTLE]].

Introduction

This document defines N-Triples, a concrete syntax for RDF [[RDF12-CONCEPTS]]. N-Triples is an easy to parse line-based subset of Turtle [[RDF12-TURTLE]].

The syntax is a revised version of N-Triples as originally defined in the RDF Test Cases [[RDF-TESTCASES]] document. Its original intent was for writing test cases, but it has proven to be popular as an exchange format for RDF data.

An N-Triples document contains no parsing directives.

N-Triples triples are a sequence of RDF terms representing the subject, predicate, and object of an RDF Triple. These may be separated by white space (spaces, and/or tabs). This sequence is terminated by a . (optionally followed by white space and/or a comment), and a new line (optional at the end of a document).

N-Triples triples are also Turtle simple triples, but Turtle includes other representations of RDF terms and abbreviations of RDF Triples. When parsed by a Turtle parser, data in the N-Triples format will produce exactly the same triples as a parser for the N-Triples language.

The RDF graph represented by an N-Triples document contains exactly each triple matching the N-Triples triple production.

N-Triples Language

An N-Triples document allows writing down an RDF graph in a textual form. An RDF graph is made up of simple triples consisting of a subject, predicate, and object and optional blank lines. Comments may be given after a # that is not part of another lexical token and continue to the end of the line.

Simple Triples

The simplest triple statement is a sequence of (subject, predicate, and object) terms, and terminated by .. White space (spaces U+0020 or tabs U+0009) may surround terms, except where significant as noted in the grammar.

Comments are treated as white space, and may be given after a # that is not part of another lexical token and continue to the end of the line.

Triple Terms

A triple term may be the object of an RDF triple.

A triple term is represented as a tripleTerm with subject, predicate, and object preceded by <<(, and followed by )>>. Note that triple terms may be nested.

IRIs

IRIs may be written only as resolved IRIs. IRIs are preceded by < and followed by >, and may contain numeric escape sequences (described below). For example <http://example.org/#green-goblin>.

RDF Literals

Literals are used to identify values such as strings, numbers, dates.

Literals (Grammar production Literal) have a lexical form followed by either a language tag (possibly including base direction), a datatype IRI, or neither.

The representation of the lexical form consists of an initial delimiter ", a sequence of permitted characters or numeric escape sequence or string escape sequence, and a final delimiter.

Literals may not contain the characters ", LF, or CR except in their escaped forms. In addition \ may not appear in any quoted literal except as part of an escape sequence and a " character can only be included in a quoted literal using an escape sequence.

The corresponding lexical form is the characters between the delimiters, after processing any escape sequences. If present, the LANG_DIR terminal matches the language tag and optionally the base direction. The language tag is preceded by an @, and, if present, the base direction is separated from the language tag by --. If there is no language tag, there may be a datatype IRI, preceded by ^^. If there is no datatype IRI and no language tag, then it is a simple literal and the datatype is http://www.w3.org/2001/XMLSchema#string.

RDF Blank Nodes

As in N-Triples, RDF blank nodes are expressed as _: followed by a blank node label which is a series of name characters. The characters in the label are built upon PN_CHARS_BASE, liberalized as follows:

The characters _ and the digit characters 0–9, inclusive may appear anywhere in a blank node label.
The character . may appear anywhere except the first or last character.
The characters -, ·, ‿, ⁀, and the combining diacritical marks (U+0300 to U+036F) are permitted anywhere except the first character.

A fresh RDF blank node is allocated for each unique blank node identifier in a document. Repeated use of the same blank node identifier identifies the same blank node.

A Canonical form of N-Triples

This section defines a canonical form of N-Triples which has a completely specified layout. The grammar for the language is unchanged.

While the N-Triples syntax allows choices for the representation and layout of RDF data, the canonical form of N-Triples provides a unique syntactic representation of any triple. Each code point can be represented by only one of UCHAR, ECHAR, or unencoded character, where the relevant production allows for a choice in representation. Each triple is represented entirely on a single line with specified white space.

Canonical N-Triples has the following additional constraints on layout:

White space MUST NOT be used except after subject, predicate, and object, any of which MUST be a single space.
Literals with the datatype http://www.w3.org/2001/XMLSchema#string MUST NOT use the datatype IRI part of the literal, and are represented using only STRING_LITERAL_QUOTE.
HEX MUST use only digits ([0–9]) and uppercase letters ([A–F]).
Alphabetic characters in LANG_DIR MUST use only the lowercase letters ([a–z]) with any uppercase letters case mapped to lowercase.
Within STRING_LITERAL_QUOTE:
- Characters BS, HT, LF, FF, CR, ", and \ MUST be encoded using ECHAR.
- Characters in the range from U+0000 to U+0007, VT, characters in the range from U+000E to U+001F, DEL, and characters not matching the Char production from [[XML11]] MUST be represented by UCHAR using a lowercase \u with 4 HEXes.
- All characters not required to be represented by ECHAR or UCHAR MUST be represented by their native [[UNICODE]] representation.
The token EOL MUST be a single LF.
The final EOL MUST be provided.

This specification defines conformance criteria for:

N-Triples documents
Canonical N-Triples documents
N-Triples parsers

A conforming N-Triples document is an RDF string that conforms to the grammar and additional constraints defined in , starting with the ntriplesDoc production. An N-Triples document serializes an RDF graph.

A conforming Canonical N-Triples document is an N-Triples document that follows the additional constraints of Canonical N-Triples.

A conforming N-Triples parser is a system capable of reading N-Triples documents on behalf of an application. It makes the serialized RDF graph, as defined in , available to the application, usually through some form of API.

The IRI that identifies the N-Triples language is: http://www.w3.org/ns/formats/N-Triples

Media Type and Content Encoding

The media type of N-Triples is application/n-triples. The content encoding of N-Triples is always UTF-8. See N-Triples Media Type for the media type registration form.

Other Media Types

N-Triples has been historically provided with other media types. N-Triples may also be provided as text/plain. When used in this way N-Triples MUST use the escaped form of any character outside US-ASCII. As N-Triples is a subset of Turtle an N-Triples document MAY also be provided as text/turtle. In both of these cases the document is not an N-Triples document as an N-Triples document is only provided as application/n-triples.

N-Triples Grammar

An N-Triples document is an RDF string encoded in UTF-8 [[!RFC3629]].

White Space

White space (spaces, and/or tabs) is allowed outside of terminals. Rule names below in capitals indicate where white space is significant.

White space is significant in the production STRING_LITERAL_QUOTE.

A blank line, consisting of only white space and/or a comment, may appear wherever a triple production is allowed, and are treated as white space.

N-Triples allows only horizontal white space (spaces or tabs) as compared to Turtle [[RDF12-TURTLE]] which also treats LF and CR as white space.

Comments

Comments in N-Triples start at # outside an IRIREF or STRING_LITERAL_QUOTE, and continue to the end of line — marked by character CR or LF — or to the end of file, if there is no end of line after the comment marker. Comments are treated as white space.

Grammar

The EBNF used here is defined in XML 1.0 [[EBNF-NOTATION]].

Escape sequence rules are the same as Turtle [[RDF12-TURTLE]]. However, as only the STRING_LITERAL_QUOTE production is allowed new lines in literals MUST be escaped.

A text version of this grammar is available here.

Selected Terminal Literal Strings

This document uses some specific terminal literal strings [[EBNF-NOTATION]]. To clarify the Unicode code points used for these terminal literal strings, the following table describes specific characters and sequences used throughout this document.

Code	Glyph	Description
`U+0008`	`BS`	Backspace
`U+0009`	`HT`	Horizontal tab
`U+000A`	`LF`	Line feed
`U+000B`	`VT`	Vertical tab
`U+000C`	`FF`	Form feed
`U+000D`	`CR`	Carriage return
`U+0022`	`"`	Quotation mark
`U+0023`	`#`	Number sign
`U+002D`	`-`	Hyphen
`U+002E`	`.`	Full stop
`U+0030`	`0`	Digit zero
`U+0039`	`9`	Digit nine
`U+003B`	`:`	Colon
`U+003C`	`<`	Less-than sign
`U+003E`	`>`	Greater-than sign
`U+0040`	`@`	At sign
`U+0041`	`A`	Latin capital letter A
`U+0046`	`F`	Latin capital letter F
`U+005C`	`\`	Backslash
`U+005F`	`_`	Underscore
`U+0061`	`a`	Latin small letter A
`U+007A`	`F`	Latin small letter Z
`U+007F`	`DEL`	Delete
`U+00B7`	`·`	Middle dot
`U+203F`	`‿`	Undertie
`U+2040`	`⁀`	Character tie

Other short terminal literal strings are composed of specific sequences of Unicode characters:

space: U+0020
<<(: two concatenated less-than sign characters, each having the code point U+003C, followed by a left parenthesis character, having the code point U+0028
)>>: a left parenthesis character, having the code point U+0029 followed by two concatenated greater-than sign characters, each having the code point U+003E
^^: two concatenated circumflex accent characters, each having the code point U+005E
_:: _ followed by :
--: two concatenated - characters

Parsing

Parsing N-Triples requires a state of one item:

Map[string -> blank node] bnodeLabels — A mapping from string to blank node.

RDF Term Constructors

This table maps productions and lexical tokens to RDF terms or components of RDF terms listed in :

production	type	procedure
BLANK_NODE_LABEL	blank node	The string after `_:`, is a key in bnodeLabels. If there is no corresponding blank node in the map, one is allocated.
IRIREF	IRI	The characters between `<` and `>` are taken, with escape sequences unescaped, to form the IRI.
LANG_DIR	language tag	The characters following the `@` form the language tag and optionally the base direction, if the matched characters include `--`.
STRING_LITERAL_QUOTE	lexical form	The characters between the outermost quotation marks (`"`) are taken, with escape sequences unescaped, to form the string of a lexical form.
literal	literal	The literal has a lexical form of the first rule argument, `STRING_LITERAL_QUOTE`, and either a language tag with optional base direction from `LANG_DIR` or a datatype IRI of `iri`, depending on which rule matched the input. If the `LANG_DIR` rule matched, the language tag and base direction are taken from LANG_DIR. If there is no base direction, the datatype is `rdf:langString`. If there is a base direction, the datatype is `rdf:dirLangString`. If neither `LANG_DIR` nor datatype IRI match, the literal has a datatype of `xsd:string`.
tripleTerm	triple term	The triple term is composed of the terms constructed from the `subject`, `predicate`, and `object` productions.

RDF Triple Construction

An N-Triples document defines an RDF graphs composed of a set of RDF Triples. The triple production produces a triple defined by the terms constructed for subject, predicate, and object.

Privacy Considerations

The N-Triples format is used to express arbitrary application data, which may include the expression of personally identifiable information (PII) or other information which could be considered sensitive. Authors publishing such information are advised to carefully consider the needs and use of publishing such information, as well as the applicable regulations for the regions where the data is expected to be consumed and potentially revealed (e.g., GDPR, CCPA, others), particularly whether authorization measures are needed for access to the data.

Security Considerations

The STRING_LITERAL_QUOTE production allows the use of unescaped control characters. Although this specification does not directly expose this content to an end user, it might be presented through a user agent, which may cause the presented text to be obfuscated due to presentation of such characters.

N-Triples is a general-purpose assertion language; applications may evaluate given data to infer more assertions or to dereference IRIs, invoking the security considerations of the scheme for that IRI. Note in particular, the privacy issues in [[RFC3023]] section 10 for HTTP IRIs. Data obtained from an inaccurate or malicious data source may lead to inaccurate or misleading conclusions, as well as the dereferencing of unintended IRIs. Care must be taken to align the trust in consulted resources with the sensitivity of the intended use of the data; inferences of potential medical treatments would likely require different trust than inferences for trip planning.

The N-Triples language is used to express arbitrary application data; security considerations will vary by domain of use. Security tools and protocols applicable to text (for example, PGP encryption, checksum validation, password-protected compression) may also be used on N-Triples documents. Security/privacy protocols must be imposed which reflect the sensitivity of the embedded information.

N-Triples can express data which is presented to the user, such as RDF Schema labels. Applications rendering strings retrieved from untrusted N-Triples documents, or using unescaped characters, SHOULD use warnings and other appropriate means to limit the possibility that malignant strings might be used to mislead the reader. The security considerations in the media type registration for XML ([[RFC3023]] section 10) provide additional guidance around the expression of arbitrary data and markup.

N-Triples uses IRIs as term identifiers. Applications interpreting data expressed in N-Triples SHOULD address the security issues of [[[RFC3987]]] [[RFC3987]] Section 8, as well as [[[RFC3986]]] [[RFC3986]] Section 7.

Multiple IRIs may have the same appearance. Characters in different scripts may look similar (for instance, a Cyrillic "о" may appear similar to a Latin "o"). A character followed by combining characters may have the same visual representation as another character (for example, LATIN SMALL LETTER "E" followed by COMBINING ACUTE ACCENT has the same visual representation as LATIN SMALL LETTER "E" WITH ACUTE). Any person or application that is writing or interpreting data in N-Triples must take care to use the IRI that matches the intended semantics, and avoid IRIs that may look similar. Further information about matching visually similar characters can be found in [[[UNICODE-SECURITY]]] [[UNICODE-SECURITY]] and [[[RFC3987]]] [[RFC3987]] Section 8.

Internet Media Type, File Extension and Macintosh File Type

The Internet Media Type (formerly known as MIME Type) for N-Quads is "application/n-triples".

The information that follows has been submitted to the Internet Engineering Steering Group (IESG) for review, approval, and registration with IANA.

Type name:

application

Subtype name:

n-triples

Required parameters:

None

Optional parameters:

None

Encoding considerations:

The syntax of N-Triples is expressed over code points in Unicode [[UNICODE]]. The encoding is always UTF-8 [[UTF-8]].

Unicode code points may also be expressed using an \uXXXX (U+0 to U+FFFF) or \UXXXXXXXX syntax (for U+10000 onwards) where X is a hexadecimal digit [0-9A-F]

Security considerations:

See .

Interoperability considerations:

There are no known interoperability issues.

Published specification:

This specification.

Applications which use this media type:

N-Triples is used widely for representing RDF data. There are implementations available in most common programming languages.

Additional information:

Magic number(s):: None.
File extension(s):: .nt;
Macintosh file type code(s):: TEXT

Person & email address to contact for further information:

RDF-star Working Group <public-rdf-star-wg@w3.org>

Intended usage:

Common

Restrictions on usage:

None

Author(s):

The N-Quads specification is the product of the RDF-star WG. The W3C reserves change control over this specifications.

Acknowledgments

Acknowledgments for RDF 1.1

The editor of the RDF 1.1 edition acknowledges valuable contributions from Gregg Kellogg, Eric Prud'hommeaux, Dave Beckett, David Robillard, Gregory Williams, Pat Hayes, Richard Cyganiak, Henry S. Thompson, Peter Ansell, Evan Patton and David Booth.

This specification is a product of extended deliberations by the members of the RDF Working Group. It draws upon the earlier specification in [[RDF-TESTCASES]], edited by Dave Beckett.

Acknowledgments for RDF 1.2

The editors of the RDF 1.2 edition acknowledge valuable contributions from Andy Seaborne.

In addition to the editors, the following people have contributed to this specification:

Recognize members of the Task Force? Not an easy to find list of contributors.

Changes between RDF 1.1 and RDF 1.2

Better align the use of white space and comments with [[RDF12-TURTLE]].
Removed language about white space use between terminals that would otherwise be (mis-)recognized, is this can't happen in N-Triples.
Clarify the use of blank lines, including those composed of white space and/or comments. Comments can appear at the end of a triple before the newline as was already evident from .
Create separate subsections of for White space and Comments, better mirroring [[RDF12-TURTLE]].
Updated the PN_CHARS_U grammar production to be consisten with with Turtle.
Adds support for triple terms as described in with updates to .
Separated from and updated language.
Changes the `LANGTAG` terminal production to LANG_DIR to include an optional base direction.
Changes to clarify use of datatype IRIs and expand the use of escapes in literals and to require that the characters in LANG_DIR be in lowercase.