RFC 2047

MIME (Multipurpose Internet Mail Extensions) Part Three: Message Header Extensions for Non-ASCII Text

📅 published November 1996, from ietf

MIME (Multipurpose Internet Mail Extensions) Part Three: Message Header Extensions for Non-ASCII Text 💖

okay bestie, so this is RFC 2047 🎀 It came from the Network Working Group, written by K. Moore at the University of Tennessee, and it dropped in November 1996 ✨ It's a Standards Track doc, and it obsoletes RFCs 1521, 1522, and 1590, so those are officially retired and this one is the replacement 💅

Status of This Memo

this document specifies an Internet standards track protocol for the Internet community and asks for discussion and suggestions for improvements 🦋 for the standardization state and status of this protocol, check the current edition of the "Internet Official Protocol Standards" (STD 1). distribution of this memo is unlimited 🌸

Abstract

okay so STD 11, RFC 822, is a message representation protocol that gets super detailed about US-ASCII message headers, and it leaves the message content, or message body, as flat US-ASCII text 📝 this whole MIME set, which is the Multipurpose Internet Mail Extensions (MIME), redefines the message format so you can have:

(1) textual message bodies in character sets other than US-ASCII,

(2) an extensible set of different formats for non-textual message bodies,

(3) multi-part message bodies, and

(4) textual header information in character sets other than US-ASCII ✨

these documents build on earlier work in RFC 934, STD 11, and RFC 1049, but they extend and revise it. because RFC 822 said so little about message bodies, these documents are mostly orthogonal to RFC 822 (rather than a revision of it) 🧚

this particular document is the third one in the series 🎀 it describes extensions to RFC 822 that let non-US-ASCII text data show up in Internet mail header fields.

1. Introduction ✨

okay so RFC 2045 describes a way to label textual body parts that are coded in different character sets, plus ways to encode those body parts as sequences of printable US-ASCII characters 💖 this memo describes similar techniques that let you encode non-ASCII text in various parts of an RFC 822 [2] message header, in a way that's unlikely to confuse the message handling software you already have 🫶

like the RFC 2045 encodings, these techniques are built so non-ASCII characters in headers aren't easily messed up by the quirks of existing Internet mail handling programs 😭 some mail relaying programs are known to (a) delete some message header fields while keeping others, (b) rearrange the order of addresses in To or Cc fields, (c) rearrange the (vertical) order of header fields, and/or (d) "wrap" message headers at different places than the original message 🙈 and some mail reading programs have trouble parsing message headers that are legal under RFC 822 but use backslash-quoting to "hide" special characters like "<", ",", or ":", or that use other rarely-used features of that spec 💀

it's unfortunate that these programs don't read RFC 822 headers correctly, but breaking them would cause severe operational problems for the Internet mail system 🥺 so the extensions in this memo do not rely on little-used features of RFC 822 🌈

instead, certain sequences of "ordinary" printable ASCII characters (called "encoded-words") get reserved for use as encoded data ✨ the syntax of encoded-words makes them unlikely to "accidentally" show up as normal text in message headers 👑 also, the characters used inside encoded-words are limited to ones that don't have special meanings in the context where the encoded-word appears 🦋

basically, an "encoded-word" is a sequence of printable ASCII characters that begins with =?, ends with ?=, and has two ?s in between 🎀 it names a character set and an encoding method, and it also holds the original text encoded as graphic ASCII characters, following the rules of that encoding method 💅

a mail composer that follows this spec gives you a way to type non-ASCII text in header fields, but then translates those fields (or the right portions of them) into encoded-words before putting them in the message header 🧚

a mail reader that follows this spec recognizes encoded-words when they show up in certain parts of the message header 👀 instead of displaying the encoded-word "as is," it reverses the encoding and displays the original text in the designated character set 🌸

NOTES

this memo leans heavily on notation and terms defined in RFC 822 and RFC 2045 🤓 the syntax for the ABNF used here is defined in RFC 822, and lots of the terminal and nonterminal symbols from RFC 822 are used in the grammar for the header extensions defined here 📚 among the RFC 822 symbols referenced in this memo are: 'addr-spec', 'atom', 'CHAR', 'comment', 'CTLs', 'ctext', 'linear-white-space', 'phrase', 'quoted-pair', 'quoted-string', 'SPACE', and 'word' 💜 getting this protocol extension working takes careful attention to the RFC 822 definitions of these terms 🫶

when this memo says "ASCII," it means the "7-Bit American Standard Code for Information Interchange," ANSI X3.4-1986 ✨ the MIME charset name for this character set is "US-ASCII" 🎀 when the memo isn't talking about the MIME charset name specifically, it just says "ASCII" for brevity and to match RFC 822 💖 but implementors, be warned: the character set name must be spelled "US-ASCII" in MIME message and body part headers 🚨

this memo specifies a protocol for representing non-ASCII text in message headers 🌈 it specifically DOES NOT define any translation between "8-bit headers" and pure ASCII headers, and it doesn't assume any such translation is possible 😤

2. Syntax of encoded-words 🌸

an 'encoded-word' is defined by the following ABNF grammar 📝 it uses the RFC 822 notation, with one exception: white space characters MUST NOT appear between components of an 'encoded-word' 🚫

   encoded-word = "=?" charset "?" encoding "?" encoded-text "?="

   charset = token    ; see section 3

   encoding = token   ; see section 4

   token = 1*<Any CHAR except SPACE, CTLs, and especials>

   especials = "(" / ")" / "<" / ">" / "@" / "," / ";" / ":" / "
               <"> / "/" / "[" / "]" / "?" / "." / "="

   encoded-text = 1*<Any printable ASCII character other than "?"
                     or SPACE>
                  ; (but see "Use of encoded-words in message
                  ; headers", section 5)

both 'encoding' and 'charset' names are case-independent 💅 so the charset name "ISO-8859-1" is the same as "iso-8859-1," and the encoding named "Q" can be spelled either "Q" or "q" ✨

an 'encoded-word' may not be more than 75 characters long, counting 'charset', 'encoding', 'encoded-text', and the delimiters 📏 if you want to encode more text than fits in one 75-character 'encoded-word', you can use multiple 'encoded-word's, separated by CRLF SPACE 🧩

there's no limit on the length of a multiple-line header field, but each line of a header field that contains one or more 'encoded-word's is limited to 76 characters 🦋

these length restrictions exist to ease interoperability through internetwork mail gateways, and to put a cap on how much lookahead a header parser has to do (while hunting for a final ?= delimiter) before it can decide whether a token is an "encoded-word" or something else 🔥

IMPORTANT: 'encoded-word's are designed to be recognized as 'atom's by an RFC 822 parser. as a consequence, unencoded white space characters (such as SPACE and HTAB) are FORBIDDEN within an 'encoded-word'. for example, the character sequence =?iso-8859-1?q?this is some text?= would be parsed as four 'atom's, rather than as a single 'atom' (by an RFC 822 parser) or 'encoded-word' (by a parser that understands 'encoded-words'). the correct way to encode the string "this is some text" is to encode the SPACE characters as well, e.g. =?iso-8859-1?q?this=20is=20some=20text?=

the characters that may appear in 'encoded-text' are further restricted by the rules in section 5 🌷

3. Character sets 🌈

the 'charset' portion of an 'encoded-word' specifies the character set associated with the unencoded text 🎀 a 'charset' can be any of the character set names allowed in a MIME "charset" parameter of a "text/plain" body part, or any character set name registered with IANA for use with the MIME text/plain content-type 📚

some character sets use code-switching techniques to move between "ASCII mode" and other modes 🧠 if unencoded text in an 'encoded-word' contains a sequence that makes the charset interpreter switch out of ASCII mode, it MUST contain additional control codes so that ASCII mode is selected again at the end of the 'encoded-word' 🔁 (this rule applies separately to each 'encoded-word', including adjacent 'encoded-word's within a single header field 💖)

when there's a chance of using more than one character set to represent the text in an 'encoded-word', and there are no private agreements between the sender and recipients of a message, it is recommended that members of the ISO-8859-* series be used in preference to other character sets 🫶

4. Encodings ✨

okay so there are only two legal values for "encoding" right now: "Q" and "B" 🎀. Both get explained below. The "Q" encoding is recommended when most of your characters are plain ASCII, and otherwise the "B" encoding should be used 🌸. Either way, a mail reader that claims to recognize 'encoded-word's MUST be able to accept either encoding for any character set it supports 💅.

Only a subset of printable ASCII can show up in 'encoded-text' 🦋. Space and tab are NOT allowed, so you can always tell where an 'encoded-word' starts and ends ✨. The "?" character separates the parts of an 'encoded-word', so it can't appear inside the 'encoded-text' 🫶. Other characters are illegal in certain spots too. For example, an 'encoded-word' in a 'phrase' before an address in a From header field can't contain any of the "specials" from RFC 822 😭. And some characters are banned in certain contexts so messages survive trips through internetwork mail gateways 🌈.

The "B" encoding meets all of these requirements automatically 👑. The "Q" encoding lets you use a wide range of printable characters in low-stakes places in the header, like Subject, but there are fewer characters you can use in other places 🍓.

4.1. The "B" encoding

The "B" encoding is identical to the "BASE64" encoding defined by RFC 2045 🧚.

4.2. The "Q" encoding

The "Q" encoding is similar to the "Quoted-Printable" content-transfer-encoding defined in RFC 2045 💜. It's built so that text that's mostly ASCII can still be read on an ASCII terminal without decoding 🌷.

Any 8-bit value can be written as a "=" followed by two hexadecimal digits. For example, if the character set in use were ISO-8859-1, the "=" character would be encoded as "=3D", and a SPACE as "=20". (Upper case should be used for hexadecimal digits "A" through "F".) 🔥
The 8-bit hexadecimal value 20 (for example, ISO-8859-1 SPACE) can be represented as "_" (underscore, ASCII 95.). (This character may not pass through some internetwork mail gateways, but using it will greatly boost readability of "Q" encoded data in mail readers that don't support this encoding 🙈.) Note that "_" always represents hexadecimal 20, even if the SPACE character sits at a different code position in the character set in use ⭐.
8-bit values that correspond to printable ASCII characters other than "=", "?", and "_" (underscore) MAY be represented as those characters. (But see section 5 for restrictions 👀.) In particular, SPACE and TAB MUST NOT be represented as themselves within encoded words 🚫.

5. Use of encoded-words in message headers 💌

An 'encoded-word' can show up in a message header or a body part header, following these rules 💖:

An 'encoded-word' can replace a 'text' token (as defined by RFC 822) in any Subject or Comments header field, any extension message header field, or any MIME body part field where the field body is defined as '*text'. An 'encoded-word' can also appear in any user-defined ("X-") message or body part header field ✨.

Ordinary ASCII text and 'encoded-word's can show up together in the same header field. However, an 'encoded-word' that appears in a header field defined as '*text' MUST be separated from any adjacent 'encoded-word' or 'text' by 'linear-white-space' 🫶.

An 'encoded-word' can appear within a 'comment' delimited by "(" and ")", that is, wherever a 'ctext' is allowed 🎀. More precisely, the RFC 822 ABNF definition for 'comment' is amended as follows:

comment = "(" *(ctext / quoted-pair / comment / encoded-word) ")"

A "Q"-encoded 'encoded-word' which appears in a 'comment' MUST NOT contain the characters "(", ")" or " 😳 'encoded-word' that appears in a 'comment' MUST be separated from any adjacent 'encoded-word' or 'ctext' by 'linear-white-space' 💅.

It's really important to know that 'comment's are only recognized inside "structured" field bodies 🧐. In fields whose bodies are defined as '*text', "(" and ")" are treated as ordinary characters rather than comment delimiters, and rule (1) of this section applies. (See RFC 822, sections 3.1.2 and 3.1.3.) 🌈

An 'encoded-word' can replace a 'word' entity within a 'phrase', for example, one that comes before an address in a From, To, or Cc header 📬. The ABNF definition for 'phrase' from RFC 822 becomes:

phrase = 1*( encoded-word / word )

In this case, the characters allowed in a "Q"-encoded 'encoded-word' are restricted to: <upper and lower case ASCII letters, decimal digits, "!", "*", "+", "-", "/", "=", and "_" (underscore, ASCII 95.)>. An 'encoded-word' that appears within a 'phrase' MUST be separated from any adjacent 'word', 'text' or 'special' by 'linear-white-space' 🍓.

These are the ONLY places an 'encoded-word' can appear 🔒. Specifically:

An 'encoded-word' MUST NOT appear in any portion of an 'addr-spec'.
An 'encoded-word' MUST NOT appear within a 'quoted-string'.
An 'encoded-word' MUST NOT be used in a Received header field.
An 'encoded-word' MUST NOT be used in parameter of a MIME Content-Type or Content-Disposition field, or in any structured field body except within a 'comment' or 'phrase'.

The 'encoded-text' in an 'encoded-word' has to be self-contained 🧩. 'encoded-text' MUST NOT be continued from one 'encoded-word' to another. This means the 'encoded-text' portion of a "B" 'encoded-word' will be a multiple of 4 characters long, and for a "Q" 'encoded-word', any "=" character in the 'encoded-text' portion will be followed by two hexadecimal characters 🔢.

Each 'encoded-word' MUST encode an integral number of octets 🎯. The 'encoded-text' in each 'encoded-word' must be well-formed according to the encoding specified, and the 'encoded-text' may not be continued in the next 'encoded-word'. (For example, =?charset?Q?=?= =?charset?Q?AB?= would be illegal, because the two hex digits "AB" must follow the "=" in the same 'encoded-word'.) 💀

Each 'encoded-word' MUST represent an integral number of characters 🌸. A multi-octet character may not be split across adjacent 'encoded-word's 🙅.

Only printable and white space character data should be encoded using this scheme ✨. However, since these encoding schemes can encode any octet value, mail readers that implement this decoding should also make sure that displaying the decoded data on the recipient's terminal won't cause unwanted side-effects 🛡️.

Using these methods to encode non-textual data (like pictures or sounds) is not defined by this memo 🖼️. Using 'encoded-word's for strings of purely ASCII characters is allowed, but discouraged 🙃. In rare cases it may be necessary to encode ordinary text that looks like an 'encoded-word' 🤷‍♀️.

6. Support of 'encoded-word's by mail readers 📖

6.1. Recognition of 'encoded-word's in message headers

A mail reader must parse the message and body part headers according to the rules in RFC 822 to correctly recognize 'encoded-word's 🕵️‍♀️.

Here's how 'encoded-word's get recognized 💫:

Any message or body part header field defined as '*text', or any user-defined header field, should be parsed like this: starting at the beginning of the field-body, and right after each occurrence of 'linear-white-space', each sequence of up to 75 printable characters (not containing any 'linear-white-space') should be checked to see if it's an 'encoded-word' according to the syntax rules in section 2. Any other sequence of printable characters should be treated as ordinary ASCII text 🎀.
Any header field not defined as '*text' should be parsed according to the syntax rules for that header field. However, any 'word' that appears within a 'phrase' should be treated as an 'encoded-word' if it meets the syntax rules in section 2. Otherwise it should be treated as an ordinary 'word' 🦋.
Within a 'comment', any sequence of up to 75 printable characters (not containing 'linear-white-space') that meets the syntax rules in section 2 should be treated as an 'encoded-word'. Otherwise it should be treated as normal comment text 💬.
A MIME-Version header field is NOT required to be present for 'encoded-word's to be interpreted according to this specification 🙌. One reason is that the mail reader isn't expected to parse the whole message header before displaying lines that might contain 'encoded-word's 🏃‍♀️.

6.2. Display of 'encoded-word's

Any 'encoded-word's recognized this way are decoded, and if possible, the resulting unencoded text is displayed in the original character set 🌈.

NOTE: Decoding and display of encoded-words happens after a structured field body is parsed into tokens. That means it's possible to hide 'special' characters in encoded-words which, once displayed, look exactly like 'special' characters in the surrounding text 😈. For this and other reasons, it is NOT generally possible to translate a message header containing 'encoded-word's into an unencoded form that an RFC 822 mail reader can parse 🫠.

When displaying a header field that contains several 'encoded-word's, any 'linear-white-space' separating two adjacent 'encoded-word's gets ignored 🧵. (This lets you use multiple 'encoded-word's to represent long strings of unencoded text, without having to split 'encoded-word's wherever spaces appear in the unencoded text ✂️.)

If other encodings get defined in the future, and the mail reader doesn't support the encoding used, it may either (a) display the 'encoded-word' as ordinary text, or (b) substitute an appropriate message saying the text couldn't be decoded 🌷.

If the mail reader doesn't support the character set used, it may (a) display the 'encoded-word' as ordinary text (that is, as it appears in the header), (b) make a "best effort" to display using whichever characters are available, or (c) substitute an appropriate message saying the decoded text couldn't be displayed 🎭.

If the character set being used employs code-switching techniques, display of the encoded text implicitly begins in "ASCII mode" 🔁. On top of that, the mail reader must make sure the output device is back in "ASCII mode" once the 'encoded-word' has been displayed 🧹.

6.3. Mail reader handling of incorrectly formed 'encoded-word's

It's possible for an 'encoded-word' that's legal according to the syntax in section 2 to still be incorrectly formed according to the rules for the encoding being used 🤔. For example:

An 'encoded-word' that contains characters which aren't legal for a particular encoding (for example, a "-" in the "B" encoding, or a SPACE or HTAB in either the "B" or "Q" encoding) is incorrectly formed 🚩.
Any 'encoded-word' that encodes a non-integral number of characters or octets is incorrectly formed 🧮.

A mail reader doesn't need to try to display the text associated with an incorrectly formed 'encoded-word' 🙈. However, a mail reader MUST NOT prevent the display or handling of a message because an 'encoded-word' is incorrectly formed 💖.

7. Conformance 🎀

okay bestie, this is where the rules get real 💅 A mail composing program that claims to follow this spec MUST make sure that any string of non-white-space printable ASCII characters inside a *text or *ctext that starts with "=?" and ends with "?=" is a valid 'encoded-word'. ("begins" means: at the start of the field-body, right after linear-white-space, or right after a "(" for an 'encoded-word' inside *ctext. "ends" means: at the end of the field-body, right before linear-white-space, or right before a ")" for an 'encoded-word' inside *ctext.) On top of that, any 'word' inside a 'phrase' that begins with "=?" and ends with "?=" must be a valid 'encoded-word' 🫶

A mail reading program that claims compliance must be able to tell 'encoded-word's apart from 'text', 'ctext', or 'word's, following the rules in section 6, any time they show up in the right places in message headers 🔍 It must support both the "B" and "Q" encodings for any character set it supports. The program must be able to display the unencoded text if the character set is "US-ASCII". For the ISO-8859-* character sets, the mail reading program must at least be able to display the characters that are also in the ASCII set 🌸

8. Examples 🦋

here are some message headers with 'encoded-word's in them, so you can see the vibe:

From: =?US-ASCII?Q?Keith_Moore?= <moore@cs.utk.edu>
To: =?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= <keld@dkuug.dk>
CC: =?ISO-8859-1?Q?Andr=E9?= Pirard <PIRARD@vm1.ulg.ac.be>
Subject: =?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=
 =?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?=

okay so the last "=" in the first 'encoded-word' of that Subject field is 100% necessary 😭 Each 'encoded-word' has to be self-contained, because that "=" is what finishes a group of 4 base64 characters representing 2 octets. You could have squeezed one more octet into the first 'encoded-word' (so it'd hold an exact multiple of 3 encoded octets), except the second 'encoded-word' uses a different 'charset', so nope 💀

From: =?ISO-8859-1?Q?Olle_J=E4rnefors?= <ojarnef@admin.kth.se>
To: ietf-822@dimacs.rutgers.edu, ojarnef@admin.kth.se
Subject: Time for ISO 10646?

To: Dave Crocker <dcrocker@mordor.stanford.edu>
Cc: ietf-822@dimacs.rutgers.edu, paf@comsol.se
From: =?ISO-8859-1?Q?Patrik_F=E4ltstr=F6m?= <paf@nada.kth.se>
Subject: Re: RFC-HDR care and feeding
From: Nathaniel Borenstein <nsb@thumper.bellcore.com>
      (=?iso-8859-8?b?7eXs+SDv4SDp7Oj08A==?=)
To: Greg Vaudreuil <gvaudre@NRI.Reston.VA.US>, Ned Freed
   <ned@innosoft.com>, Keith Moore <moore@cs.utk.edu>
Subject: Test of new header generator
MIME-Version: 1.0
Content-type: text/plain; charset=ISO-8859-1

The next examples show how text containing 'encoded-word's acts when it appears in a structured field body. The rules are a little different for fields defined as '*text', because "(" and ")" are not recognized as 'comment' delimiters. [Section 5, paragraph (1)].

In each of the following examples, if the same sequence showed up in a '*text' field, the "displayed as" form would NOT be treated as encoded words. It would just look identical to the "encoded form". That's because each of the encoded-words in these examples sits right next to a "(" or ")" character 👀

encoded form                                displayed as
---------------------------------------------------------------------
(=?ISO-8859-1?Q?a?=)                        (a)

(=?ISO-8859-1?Q?a?= b)                      (a b)

(=?ISO-8859-1?Q?a?= =?ISO-8859-1?Q?b?=)     (ab)

(=?ISO-8859-1?Q?a?=  =?ISO-8859-1?Q?b?=)    (ab)

(=?ISO-8859-1?Q?a?=                         (ab)
    =?ISO-8859-1?Q?b?=)

(=?ISO-8859-1?Q?a_b?=)                      (a b)

(=?ISO-8859-1?Q?a?= =?ISO-8859-2?Q?_b?=)    (a b)

Within a 'comment', white space MUST appear between an 'encoded-word' and the surrounding text. [Section 5, paragraph (2)]. Between the initial "(" that starts the 'comment' and the 'encoded-word', though, you don't need any white space 🌈

White space between adjacent 'encoded-word's is not displayed. Even multiple SPACEs between 'encoded-word's are ignored for display purposes ✨ And any amount of linear-space-white between 'encoded-word's, even one that includes a CRLF followed by one or more SPACEs, is ignored for display too.

If you want a SPACE to show up inside a chunk of encoded text, the SPACE MUST be encoded as part of the 'encoded-word'. And if you want a SPACE to show up between two strings of encoded text, the SPACE MAY be encoded as part of one of the 'encoded-word's. Bestie, that's the whole trick 🍓

9. References 📚

[RFC 822] Crocker, D., "Standard for the Format of ARPA Internet Text Messages", STD 11, RFC 822, UDEL, August 1982.
[RFC 2049] Borenstein, N., and N. Freed, "Multipurpose Internet Mail Extensions (MIME) Part Five: Conformance Criteria and Examples", RFC 2049, November 1996.
[RFC 2045] Borenstein, N., and N. Freed, "Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies", RFC 2045, November 1996.
[RFC 2046] Borenstein N., and N. Freed, "Multipurpose Internet Mail Extensions (MIME) Part Two: Media Types", RFC 2046, November 1996.
[RFC 2048] Freed, N., Klensin, J., and J. Postel, "Multipurpose Internet Mail Extensions (MIME) Part Four: Registration Procedures", RFC 2048, November 1996.

10. Security Considerations 🔒

Security issues are not discussed in this memo. 💀

11. Acknowledgements 🫶

The author wishes to thank Nathaniel Borenstein, Issac Chan, Lutz Donnerhacke, Paul Eggert, Ned Freed, Andreas M. Kirchwitz, Olle Jarnefors, Mike Rosin, Yutaka Sato, Bart Schaefer, and Kazuhiko Yamamoto. They gave helpful advice, insightful comments, and illuminating questions on earlier versions of this specification, and they are absolutely iconic for it 👑

12. Author's Address 🖋️

Keith Moore
University of Tennessee
107 Ayres Hall
Knoxville TN 37996-1301

EMail: moore@cs.utk.edu

Appendix - changes since RFC 1522 (in no particular order) 🌸

explicitly state that the MIME-Version is not requried to use 'encoded-word's.
add explicit note that SPACEs and TABs are not allowed within 'encoded-word's, explaining that an 'encoded-word' must look like an 'atom' to an RFC822 parser.values, to be precise).
add examples from Olle Jarnefors (thanks!) which illustrate how encoded-words with adjacent linear-white-space are displayed.
explicitly list terms defined in RFC822 and referenced in this memo
fix transcription typos that caused one or two lines and a couple of characters to disappear in the resulting text, due to nroff quirks.
clarify that encoded-words are allowed in '*text' fields in both RFC822 headers and MIME body part headers, but NOT as parameter values.
clarify the requirement to switch back to ASCII within the encoded portion of an 'encoded-word', for any charset that uses code switching sequences.
add a note about 'encoded-word's being delimited by "(" and ")" within a comment, but not in a *text (how bizarre!).
fix the Andre Pirard example to get rid of the trailing "_" after the =E9. (no longer needed post-1342).
clarification: an 'encoded-word' may appear immediately following the initial "(" or immediately before the final ")" that delimits a comment, not just adjacent to "(" and ")" within *ctext.
add a note to explain that a "B" 'encoded-word' will always have a multiple of 4 characters in the 'encoded-text' portion.
add note about the "=" in the examples
note that processing of 'encoded-word's occurs after parsing, and some of the implications thereof.
explicitly state that you can't expect to translate between 1522 and either vanilla 822 or so-called "8-bit headers".
explicitly state that 'encoded-word's are not valid within a 'quoted-string'. ✨💖

📦 where this page comes from

ietf: rfc2047 1996-11
💖 girlified by claude-haiku-5-5 on 2026-10-15: a language model's rewrite of the original, under its terms