Skip to content

Convertitore JSON in CSV

Converti JSON in CSV nel browser. Preset RFC 4180, Excel-EU, TSV, Pipe. Appiattisci o stringifica i dati nidificati. 100% privato, nessun upload.

Niente tracciamento Funziona nel browser Gratuito
Preset
Opzioni · , · auto · LF · header · no BOM · flatten
Delimitatore
Emetti intestazione
Virgolette
Fine riga
BOM UTF-8
Nidificato
0 caratteri 0 righe
Output CSV
0 righe · 0 colonne
Revisionato per la conformità a RFC 4180, la gestione della locale Excel-EU, il rilevamento automatico NDJSON e la preservazione della precisione degli interi grandi — Go Tools Engineering Team · May 8, 2026

Cos'è il CSV e perché convertire da JSON?

Il CSV (Comma-Separated Values) è il formato di dati tabellare più antico e più ampiamente supportato in informatica — ogni applicazione di fogli di calcolo, ogni database, ogni strumento di analisi e la maggior parte dei linguaggi di programmazione hanno un supporto CSV di prima classe. JSON, al contrario, è il formato universale per le risposte API, la configurazione e lo scambio di dati strutturati. Convertire tra i due è una delle attività più comuni nel data engineering: ricevi JSON da un'API o da un database NoSQL e ti serve un CSV da caricare in Excel per l'analisi, in una tabella Postgres tramite COPY o in un warehouse BigQuery / Snowflake. Questo strumento è costruito per quel percorso di conversione e gestisce quattro scenari che la maggior parte dei convertitori online sbaglia.

Questo strumento ha quattro differenziatori importanti rispetto ai tipici convertitori online:

**1. Parser RFC 4180 a macchina a stati.** Il CSV sembra semplice ma le regole di virgolettatura sono sottili: un campo racchiuso tra virgolette doppie può contenere virgole, newline incorporati e virgolette doppie escapate (raddoppiate, come ""). I parser ingenui split-by-comma si rompono sui dati reali — indirizzi con virgole, campi di testo multi-riga e valori quotati che contengono virgolette. Questo strumento implementa un vero parser a macchina a stati che segue l'RFC 4180 (la specifica IETF per CSV), gestendo correttamente i campi quotati, i delimitatori incorporati, i fine riga incorporati e le virgolette escapate in entrambe le direzioni. L'output è round-trippable attraverso il modulo csv di Python, PostgreSQL COPY, AWS S3 SELECT e qualsiasi parser conforme.

**2. Flatten a senso unico / Stringify reversibile.** Il JSON nidificato è fondamentalmente incompatibile con la forma tabellare piatta del CSV, e la maggior parte dei convertitori corrompe silenziosamente i dati quando incontra un oggetto o un array nidificato. Questo strumento ti offre una scelta esplicita: la modalità Flatten produce chiavi puntate (customer.address.city) e chiavi indicizzate (items.0.sku) per la disposizione più pulita in foglio di calcolo — leggibile in Excel ma lossy per i round-trip. La modalità Stringify mantiene array e oggetti come JSON in una singola cella — meno bella ma completamente round-trippable: CSV → JSON → CSV produce dati identici quando abbinata a Inferisci tipi sul percorso inverso. Scegli in base al tuo obiettivo: analisi in Excel (Flatten) o round-trip di pipeline (Stringify).

**3. Rilevamento di interi grandi.** Il tipo Number di JavaScript usa il float a doppia precisione IEEE 754 e arrotonda silenziosamente gli interi oltre 2^53 - 1 (9007199254740991). Questo morde il JSON reale: gli ID snowflake di Twitter, gli ID di Discord, i campi MongoDB Long e il resourceVersion di Kubernetes sono tutti interi a 64 bit che superano l'intervallo sicuro. La maggior parte degli strumenti JSON basati su browser produce silenziosamente numeri sbagliati senza avvisare. Questo strumento rileva i valori interi grandi durante l'analisi, mostra un banner di avviso che elenca i campi interessati e preserva le cifre originali come stringhe nell'output CSV, così Excel e Google Sheets non li tronchino in notazione scientifica.

**4. Privacy 100% basata su browser.** I tuoi dati JSON — che spesso contengono PII degli utenti, export di database interni, chiavi API incorporate nei payload e segreti di produzione — non lasciano mai il browser. Nessun dato viene inviato a nessun server, nessun log, nessuna analisi che catturi l'input. Puoi verificarlo nella scheda Rete del browser. Questo è l'unico modo sicuro per gestire dati sensibili in uno strumento online. Vedi la direzione inversa cliccando Inverti o usa il nostro Convertitore JSON in YAML complementare quando il tuo target è YAML. Devi validare il JSON prima di convertirlo? Prova il nostro Formattatore JSON.

I punti di forza del CSV sono universalità e semplicità: ogni strumento lo legge, i parser sono minuscoli e il formato del file è leggibile dall'uomo in qualsiasi editor di testo. I suoi punti deboli sono la mancanza di informazioni sul tipo (tutto è una stringa finché non lo dici al parser), nessun supporto nativo per strutture nidificate e stranezze specifiche delle locale (punti e virgola Excel-EU, CRLF Windows vs LF Unix). I punti di forza del JSON sono esattamente l'opposto: tipi precisi, nidificazione nativa e una specifica rigorosa che si analizza in modo identico ovunque. Lo strumento giusto dipende dal consumatore: umano che legge un foglio di calcolo → CSV, macchina che consuma un'API → JSON. Questo convertitore gestisce il ponte in entrambe le direzioni.

// Input JSON
[
  { "id": 1, "name": "Alice", "role": "admin" },
  { "id": 2, "name": "Bob", "role": "editor" }
]

// Output CSV (RFC 4180 preset: comma + CRLF + no BOM)
id,name,role
1,Alice,admin
2,Bob,editor

// Same input with Stringify mode + nested data
[
  { "id": 1, "tags": ["a", "b"] }
]

// Becomes
id,tags
1,"[""a"",""b""]"

Funzionalità Principali

Conforme a RFC 4180

Parser rigoroso a macchina a stati che segue la specifica IETF CSV: gestione corretta dei campi quotati, dei delimitatori incorporati, dei CR/LF incorporati e delle virgolette doppie escapate (raddoppiate). L'output è round-trip pulito attraverso Python csv, PostgreSQL COPY e AWS S3 SELECT.

Preset Excel, TSV e Pipe

Preset con un clic per i quattro target più comuni: RFC 4180 (virgola + CRLF), Excel (punto e virgola + CRLF + BOM UTF-8 per le locale EU), TSV (Tab + LF) e Pipe (| + LF). Passa tra i formati senza regolare manualmente cinque opzioni separate.

Appiattisci o stringifica i dati nidificati

Gestione esplicita del nidificato: Flatten produce chiavi puntate (customer.address.city) per un'analisi pulita in foglio di calcolo, Stringify mantiene array e oggetti come JSON in una cella per round-trip senza perdita. Scegli in base a se ti serve un'analisi in Excel o un round-trip di pipeline.

Rilevamento di interi grandi

Gli interi sopra 2^53 vengono rilevati durante l'analisi e preservati come stringhe nel CSV — gli ID di Twitter, gli snowflake di Discord, i campi MongoDB Long e il resourceVersion di K8s rimangono esatti invece di essere arrotondati silenziosamente dal tipo Number IEEE 754 di JavaScript.

Rilevamento automatico NDJSON

JSON delimitato da righe (.ndjson, .jsonl) viene rilevato automaticamente — incolla log in streaming, export di eventi API o output di data lake direttamente senza incapsulare manualmente in un array. Ogni riga diventa una riga nel CSV.

Bidirezionale con Inverti

Un pulsante Inverti direzione ribalta la conversione sul posto: l'input diventa CSV, l'output diventa JSON, il testo corrente viene preservato. Fai il round-trip dei tuoi dati in entrambe le direzioni per verificare la conversione senza perdita prima di inviarla a una pipeline.

Esempi

Risposta REST API

[{"id":1,"name":"Alice Chen","email":"alice@example.com","role":"admin"},{"id":2,"name":"Bob Garcia","email":"bob@example.com","role":"editor"},{"id":3,"name":"Carol Singh","email":"carol@example.com","role":"viewer"},{"id":4,"name":"Dan Müller","email":"dan@example.com","role":"viewer"}]

Output API tipico. Con l'header attivo ottieni un CSV tabellare pulito, pronto per Excel.

API Issue di GitHub

[{"id":1001,"title":"Bug: login redirects to 404","state":"open","labels":["bug","priority:high"],"user":{"login":"alice"}},{"id":1002,"title":"Feature: dark mode toggle","state":"open","labels":["enhancement"],"user":{"login":"bob"}},{"id":1003,"title":"Docs: update README","state":"closed","labels":["docs","good-first-issue"],"user":{"login":"carol"}}]

Estratto da /repos/{owner}/{repo}/issues. Flatten attivo, header attivo — espone user.login come colonna appiattita.

MongoDB mongoexport

[{"_id":{"$oid":"6634a1b2c3d4e5f600000001"},"email":"alice@example.com","metadata":{"signupDate":"2026-01-15T10:30:00Z","preferences":{"newsletter":true,"theme":"dark"}}},{"_id":{"$oid":"6634a1b2c3d4e5f600000002"},"email":"bob@example.com","metadata":{"signupDate":"2026-02-20T14:15:00Z","preferences":{"newsletter":false,"theme":"light"}}}]

Forma tipica di un export Mongo. Scegli la modalità Stringify se prevedi un round-trip CSV→JSON.

Log eventi NDJSON

{"event":"signup","user":"alice","ts":1715000000}
{"event":"login","user":"alice","ts":1715000060}
{"event":"checkout","user":"alice","ts":1715000300}

JSON delimitato da righe (.ndjson/.jsonl) viene rilevato automaticamente — incolla direttamente il contenuto del file.

Ordini e-commerce nidificati

[{"id":"ord-001","customer":{"name":"Alice Chen","email":"alice@example.com","address":{"city":"Seattle","country":"US"}},"items":[{"sku":"SKU-100","qty":2},{"sku":"SKU-205","qty":1}]},{"id":"ord-002","customer":{"name":"Bob Garcia","email":"bob@example.com","address":{"city":"Madrid","country":"ES"}},"items":[{"sku":"SKU-100","qty":1}]}]

La modalità Flatten produce chiavi puntate (customer.address.city, items.0.sku). Passa a Stringify per mantenere array e oggetti come JSON in una singola cella.

Risultati dei test Postman

[{"name":"GET /users returns 200","status":"pass","duration":142},{"name":"POST /users creates record","status":"pass","duration":287},{"name":"GET /users/999 returns 404","status":"fail","duration":98,"error":"Expected 404, got 500"},{"name":"DELETE /users/1 returns 204","status":"pass","duration":156}]

Export di test Postman/Newman. Le righe a forma mista (alcune con error) vengono completate con celle vuote — vedrai un avviso nelle note di schema.

Come Usarlo

  1. 1

    Incolla il tuo JSON

    Inserisci o incolla il tuo JSON nel campo di input qui sopra. Lo strumento accetta array di oggetti, singoli oggetti e NDJSON (JSON delimitato da righe) — rilevato automaticamente. Puoi anche cliccare «Carica esempio» per provare un campione come una risposta REST API, un export MongoDB o un log eventi NDJSON.

  2. 2

    Scegli un preset (o regola le Opzioni)

    Clicca RFC 4180 (predefinito), Excel (punto e virgola EU + BOM), TSV (Tab) o Pipe per impostare un formato di destinazione con un clic. Apri il pannello Opzioni per il controllo fine: Delimitatore, Header, Quote (Auto/Always), Fine riga (LF/CRLF), BOM e Nidificato (Flatten/Stringify).

  3. 3

    Copia o scarica il CSV

    Clicca Copia per copiare il CSV negli appunti, o Scarica per salvarlo come file .csv (.tsv con il preset TSV) pronto per Excel, Google Sheets, PostgreSQL COPY o qualsiasi pipeline di dati. Per i round-trip, clicca Inverti direzione per riconvertire il CSV in JSON sul posto.

Insidie Comuni di Conversione

Il valore di primo livello è un primitivo

Il CSV è fondamentalmente tabellare — righe di campi. Un singolo numero, stringa o booleano non ha una struttura riga/colonna su cui proiettare. Il valore JSON di primo livello deve essere un oggetto (tabella di una riga) o un array (tabella multi-riga). Avvolgi prima un primitivo in un oggetto o array.

✗ Errato
42
✓ Corretto
[{"value": 42}]

Array a forma mista (righe con chiavi diverse)

Quando le righe in un array JSON hanno chiavi diverse (alcune hanno un campo error, altre no), lo strumento unisce tutte le chiavi tra tutte le righe e riempie le celle mancanti con valori vuoti. Compare un avviso nelle note di schema così sai che le colonne sono state unite. Di solito va bene, ma verifica l'output se gli strumenti a valle si aspettano uno schema rigoroso.

✗ Errato
[
  {"name": "GET /users", "status": "pass"},
  {"name": "GET /users/999", "status": "fail", "error": "500"}
]
✓ Corretto
// Output CSV (note empty cell in row 1)
name,status,error
GET /users,pass,
GET /users/999,fail,500

Intero grande troncato da Excel

Gli ID snowflake di Twitter, gli ID di Discord e altri interi a 64 bit superano l'intervallo sicuro di JavaScript (2^53 - 1) e perdono precisione quando JSON.parse() li legge. Anche se il CSV preserva le cifre, Excel le mostrerà in notazione scientifica per impostazione predefinita. La correzione è doppia: memorizza gli ID come stringhe nel JSON prima di convertire e abilita il BOM (o usa il preset Excel) così Excel preserva la cella come testo.

✗ Errato
{"id": 9007199254740993}
// JavaScript reads as 9007199254740992 (precision lost)
✓ Corretto
{"id": "9007199254740993"}
// CSV preserves the string; Excel displays exactly

Virgola incorporata non quotata

Se costruisci il CSV a mano con un join(',') ingenuo, qualsiasi campo che contiene una virgola (Smith, Jr. o 1.234,56) romperà i confini delle colonne — il parser vede colonne in più dove dovrebbe essercene una. La modalità Auto Quote di questo strumento segue l'RFC 4180 e racchiude automaticamente tra virgolette doppie qualsiasi campo che contiene il delimitatore, una virgoletta doppia, CR o LF.

✗ Errato
name,role
Smith, Jr.,admin
// Parser reads 3 columns: "Smith", " Jr.", "admin"
✓ Corretto
name,role
"Smith, Jr.",admin
// Parser reads 2 columns: "Smith, Jr.", "admin"

File Excel-EU illeggibile come CSV con virgola

Le locale europee di Excel (Germania, Francia, Spagna, Italia, ecc.) riservano la virgola al separatore decimale e usano i punti e virgola come delimitatore di campo. Un CSV standard delimitato da virgole si apre con ogni riga collassata nella colonna A. La correzione è il preset Excel: passa a ; + CRLF + BOM UTF-8 così Excel analizza correttamente il file in qualsiasi locale.

✗ Errato
id,name,price
1,Alice,1,234.56
// Excel-EU mis-parses 1,234.56 as two columns
✓ Corretto
// Excel preset output: ; + CRLF + BOM
id;name;price
1;Alice;1234,56
// Excel-EU reads cleanly with comma decimal

NDJSON non rilevato (forma di input)

Il rilevamento automatico NDJSON richiede un valore JSON valido per riga, senza parentesi quadre di array iniziali o finali. Se incolli un array JSON di array, o se il tuo file ha un [ iniziale e un ] finale, lo strumento lo tratta come un singolo valore JSON, non come NDJSON. Rimuovi le parentesi di wrapping e assicurati che ogni riga sia un oggetto JSON autonomo.

✗ Errato
[
  {"event": "signup"},
  {"event": "login"}
]
// Detected as a regular JSON array (works, but not NDJSON path)
✓ Corretto
{"event": "signup"}
{"event": "login"}
// Each line is one JSON value — auto-detected as NDJSON

Casi d'Uso Comuni

Risposta API in foglio di calcolo
Incolla una risposta REST API (array di oggetti utente/ordine/evento) e ottieni un CSV tabellare pulito pronto per Excel, Google Sheets o Numbers. Il caso d'uso più comune — analisti e PM hanno bisogno di dati a forma di foglio di calcolo, gli ingegneri spediscono JSON dal backend.
Export MongoDB in data warehouse
Converti l'output JSON di mongoexport (con wrapper $oid e documenti metadata nidificati) in CSV per il caricamento in BigQuery, Snowflake o Redshift. La modalità Stringify preserva la forma nidificata senza perdita quando gli strumenti a valle supportano JSON-in-cella.
Triage delle issue GitHub
Scarica le issue da /repos/{owner}/{repo}/issues, incolla il JSON e ottieni un CSV piatto con id, title, state, labels e user.login come colonne. Caricalo in Sheets per filtrare, ordinare e assegnare durante lo sprint planning.
Revisione di log eventi NDJSON
I log in streaming da Cloud Logging, Datadog, Vector o dalla tua pipeline arrivano spesso come NDJSON (.ndjson, .jsonl). Incolla il contenuto del file direttamente — rilevato automaticamente — e ottieni un CSV per l'analisi ad-hoc senza tirare su una vera pipeline ETL.
Estrazione di ordini e-commerce
Converti il JSON di ordini nidificati (customer.address.city, array items) in un CSV piatto per finance, fulfillment o revisione antifrode. La modalità Flatten produce una colonna per campo foglia, pronta per essere caricata in Excel per la reportistica ad-hoc.
Report di test Postman/Newman
Gli export dei test Postman includono righe a forma mista (alcune con campi error opzionali). Incolla il JSON, ottieni un CSV con tutte le chiavi unite e le celle mancanti riempite — perfetto per condividere i report di test falliti con i non-ingegneri in Sheets.

Dettagli Tecnici

Parser RFC 4180 a macchina a stati
Entrambe le direzioni usano un vero parser a macchina a stati finiti che segue l'RFC 4180. Gli stati includono UnquotedField, QuotedField, AfterQuote, RowEnd e EndOfInput. Il parser gestisce correttamente i campi quotati che contengono il delimitatore, i CR/LF incorporati all'interno dei campi quotati, le virgolette doppie escapate (raddoppiate, come "") e i newline finali. Questo produce output che esegue il round-trip senza perdita attraverso il modulo csv di Python, PostgreSQL COPY, AWS S3 SELECT e qualsiasi parser conforme.
Algoritmo di rilevamento interi grandi
Prima di passare il JSON attraverso JSON.parse() (che arrotonderebbe silenziosamente gli interi grandi tramite IEEE 754), lo strumento esegue una scansione regex sul testo JSON grezzo cercando letterali interi fuori dall'intervallo sicuro (-2^53+1 a 2^53-1). Quando vengono rilevati, i percorsi dei campi interessati vengono registrati e un banner di avviso «Intero grande» compare sotto l'output. Lo scrittore CSV preserva poi questi valori come stringhe, garantendo precisione esatta attraverso Excel, Google Sheets e qualsiasi consumatore a valle che gestisce il testo.
BOM e codifica UTF-8 per Excel
Tutto l'input e l'output è UTF-8. Il BOM UTF-8 opzionale (0xEF 0xBB 0xBF) viene anteposto all'output quando l'interruttore BOM è attivo o quando è selezionato il preset Excel. Excel su Windows usa il BOM per rilevare la codifica UTF-8 — senza di esso, Excel ricade sulla locale di sistema (Windows-1252 negli USA, Windows-1251 in Russia, ecc.) e mangia i caratteri non-ASCII. I parser moderni (Python csv, Pandas, jq, PostgreSQL) generalmente non hanno bisogno del BOM e potrebbero includerlo come carattere sparso all'inizio della prima cella, quindi lascia il BOM disattivato per le pipeline non-Excel.

Buone Pratiche

Scegli un preset prima di regolare le opzioni
I preset RFC 4180, Excel, TSV e Pipe impostano cinque opzioni in una volta sola (delimitatore, fine riga, modalità quote, BOM, header). Scegli prima il preset più vicino, poi regola le singole opzioni solo se necessario — questo evita l'errore comune di cambiare un'opzione e dimenticarne un'altra (ad esempio, passare al punto e virgola ma lasciare LF, che Excel-EU su Windows analizza ancora male).
Flatten per l'analisi, Stringify per i round-trip
Usa Flatten quando la destinazione è Excel, Sheets o un'analisi una tantum — le chiavi puntate producono la disposizione più pulita in foglio di calcolo. Usa Stringify quando hai bisogno di un round-trip CSV → JSON → CSV senza perdita di dati — array e oggetti sopravvivono come JSON in una singola cella. Cambiare a metà export e rieseguire costa poco; scegli in base al consumatore.
Usa il BOM solo per Excel
Il BOM UTF-8 è richiesto da Excel su Windows per rilevare correttamente la codifica. Ogni altro parser (Python csv, Pandas, jq, PostgreSQL COPY, BigQuery) ignora il BOM o lo include come carattere sparso all'inizio della prima cella, rompendo i nomi delle colonne. Lascia il BOM disattivato per le pipeline e attivalo (o usa il preset Excel) solo quando la destinazione è Excel.
Mantieni gli ID grandi come stringhe nel JSON
Gli ID snowflake di Twitter, gli ID di Discord, i campi MongoDB Long e il resourceVersion di K8s sono interi a 64 bit che superano l'intervallo sicuro di JavaScript (2^53 - 1). Memorizzali come stringhe JSON ("id": "9007199254740993") prima di convertire — il CSV preserverà esattamente le cifre, mentre un letterale numerico verrebbe arrotondato silenziosamente da JSON.parse().
Valida la forma delle righe prima di caricare
Le righe a forma mista (alcuni oggetti con chiavi che altri non hanno) vengono unite con celle vuote nell'output, e lo strumento mostra un avviso nelle note di schema. Per i consumatori a schema rigoroso (BigQuery, Redshift COPY), valida che tutte le righe condividano le stesse chiavi prima di esportare — oppure gestisci esplicitamente i valori mancanti nella tua pipeline. Usa il nostro Formattatore JSON per ispezionare prima la forma dell'input.

Domande Frequenti

Cosa fa questo strumento?
Converte JSON in CSV direttamente nel browser, con supporto bidirezionale: clicca Inverti direzione per riconvertire il CSV in JSON nello stesso pannello. Incolla il JSON nell'area di input e lo strumento produce l'output CSV all'istante — nessun upload, nessuna registrazione, nulla lascia il tuo dispositivo. L'output rispetta il preset scelto (RFC 4180, Excel, TSV o Pipe), così puoi incollarlo direttamente in Excel, Google Sheets, in un comando COPY di database o in qualsiasi pipeline di dati. Lo strumento gestisce array piatti di oggetti, strutture nidificate (tramite la modalità Flatten o Stringify), input NDJSON delimitato da righe e valori interi grandi che altrimenti perderebbero precisione nelle applicazioni di fogli di calcolo.
I miei dati vengono caricati da qualche parte?
No. Tutta la conversione gira al 100% lato client nel browser usando JavaScript. I tuoi dati JSON non vengono mai trasmessi, mai archiviati su alcun server, mai registrati e mai analizzati. Questo rende lo strumento sicuro per le risposte API contenenti PII, gli export di database interni, i dump MongoDB e qualsiasi dato sensibile. Puoi verificarlo nella scheda Rete del browser — incollare JSON non attiva alcuna richiesta di rete. Lo strumento non usa cookie per i dati di input e nessuna analisi di terze parti che potrebbe catturare ciò che incolli.
Qual è la differenza tra la modalità Flatten e Stringify?
La modalità Flatten produce chiavi puntate per gli oggetti nidificati e chiavi indicizzate per gli array nidificati (customer.address.city, items.0.sku), così ogni valore foglia vive nella propria colonna. È la disposizione più leggibile per l'analisi in Excel o BigQuery, ma è lossy per i round-trip perché la struttura a chiavi puntate non può essere ricostruita perfettamente. La modalità Stringify mantiene array e oggetti come JSON dentro una singola cella ({"name":"Alice","city":"Seattle"}) — meno bella in un foglio di calcolo, ma completamente round-trippable: CSV → JSON → CSV produce dati identici. Scegli Flatten per l'analisi, Stringify per la sicurezza del round-trip. Decidi prima di convertire; cambiare modalità a metà sessione riavvia la conversione sull'input corrente.
Come gestisce gli interi grandi come gli ID di Twitter o le chiavi Snowflake?
Gli interi grandi (oltre 2^53 - 1, ovvero 9007199254740991) vengono rilevati durante l'analisi del JSON e un banner di avviso compare sotto l'output. Lo strumento preserva le cifre originali come stringhe nel CSV, così Excel e Google Sheets non le tronchino in notazione scientifica. Questo è importante perché il float a doppia precisione IEEE 754 di JavaScript arrotonda silenziosamente gli interi oltre 2^53 — ad esempio, 9007199254740993 diventa 9007199254740992. Per preservare la precisione quando generi il JSON a monte, memorizza questi ID come stringhe ("id": "9007199254740993"). Lo strumento li manterrà come stringhe nel CSV senza alcuna perdita di precisione.
Perché Excel mi mostra il CSV in una sola colonna?
Le locale europee di Excel (Germania, Francia, Spagna, Italia, ecc.) si aspettano un delimitatore punto e virgola perché la virgola è riservata al separatore decimale. Quando apri un CSV delimitato da virgole in Excel-EU, ogni riga collassa nella colonna A. Usa il preset Excel di questo strumento — passa il delimitatore a ;, il fine riga a CRLF e aggiunge un BOM UTF-8 così Excel rileva correttamente la codifica e i confini delle colonne. Se condividi CSV tra regioni, l'opzione più sicura è il TSV (delimitatore Tab), che Excel gestisce in modo coerente in qualsiasi locale.
Supporta NDJSON o JSON Lines?
Sì. NDJSON (.ndjson) e JSONL (.jsonl) sono formati delimitati da righe in cui ogni riga è un valore JSON valido. Incolla il contenuto del file direttamente nell'area di input — lo strumento rileva automaticamente il formato cercando più valori JSON di primo livello separati da newline e tratta ogni riga come una riga nel CSV di output. Questa è la forma naturale per i log in streaming, gli export di eventi API e molte pipeline di data lake. NDJSON non richiede un array di wrapping, quindi non devi unire manualmente le righe in un unico documento JSON.
Cos'è l'RFC 4180?
RFC 4180 è la specifica IETF che ha codificato il formato CSV de facto nel 2005. Definisce le regole per i delimitatori (tipicamente virgola), i fine riga (CRLF), la riga di intestazione opzionale e, soprattutto, le regole di virgolettatura: i campi che contengono il delimitatore, le virgolette doppie, CR o LF devono essere racchiusi tra virgolette doppie, e le virgolette doppie incorporate vengono escapate raddoppiandole (""). Il preset RFC 4180 di questo strumento produce output strettamente conforme alla specifica: delimitatore virgola, fine riga CRLF, nessun BOM, escape automatico delle virgolette doppie. È la scelta più sicura per l'interoperabilità con i parser in Python (modulo csv), PostgreSQL COPY, AWS S3 SELECT e la maggior parte delle pipeline di dati.
Perché alcune celle sono racchiuse tra virgolette e altre no?
La modalità Quote predefinita è Auto, che segue l'RFC 4180: una cella viene racchiusa tra virgolette doppie solo quando contiene il delimitatore, una virgoletta doppia, un ritorno a capo o un newline. Questo produce il CSV più pulito e leggibile dall'uomo — valori come Alice o 42 restano senza virgolette, mentre valori come Smith, Jr. o Riga 1\nRiga 2 vengono racchiusi. Passa alla modalità Always quote per racchiudere ogni cella, anche quelle semplici — utile quando gli strumenti a valle hanno parser CSV difettosi che interpretano male i valori non quotati, o quando la pipeline del tuo team si aspetta che ogni campo sia quotato per coerenza.
Posso fare round-trip CSV → JSON → CSV senza perdita di dati?
Sì, quando l'input è piatto (senza oggetti o array nidificati). Per dati nidificati devi usare la modalità Stringify — mantiene array e oggetti come JSON in una singola cella, che torna senza perdita alla struttura originale quando inverti con Inverti direzione e Inferisci tipi. La modalità Flatten è a senso unico: produce chiavi puntate (customer.address.city) che non possono essere ricostruite perfettamente perché il parser non può distinguere una chiave puntata da un percorso nidificato. Lo strumento rileva le strutture nidificate e mostra un avviso nelle note di schema quando la sicurezza del round-trip è a rischio, così puoi cambiare modalità prima di esportare.
Come ottengo un file TSV?
Clicca il chip preset TSV. Questo passa il delimitatore a Tab, il fine riga a LF e disabilita il BOM — il formato standard per i valori separati da tab usati dagli strumenti Unix (cut, awk), dai data warehouse (BigQuery, Snowflake) e dalla maggior parte delle locale Excel senza ambiguità. Il TSV è generalmente più sicuro del CSV con virgola per la condivisione tra locale, perché è improbabile che il Tab compaia all'interno dei campi di testo, eliminando la maggior parte dei casi limite di virgolettatura. Salva l'output con estensione .tsv o .tab e la maggior parte degli strumenti lo riconoscerà automaticamente.
Cosa succede con input molto grandi?
Sopra i 100.000 caratteri o le 2.000 righe, la conversione live passa automaticamente alla modalità manuale: compare un pulsante Converti in un banner informativo e la conversione viene eseguita solo quando lo clicchi. Questo evita che il thread principale del browser si blocchi a ogni battitura durante una serializzazione pesante. Per output sopra i 5 MB o le 50.000 righe, lo strumento tronca l'anteprima a video alle prime 500 righe e mostra un banner Mostro le prime 500 di N righe — ma il pulsante Scarica produce comunque il file completo con tutte le righe incluse. Il limite massimo è 10 MB di input; oltre questo lo strumento mostra un errore e ti chiede di ridurre l'input.
Quali codifiche sono supportate?
Input e output sono entrambi UTF-8. UTF-8 copre ogni set di caratteri moderno, inclusi emoji, ideogrammi CJK, arabo, ebraico e segni combinanti. L'unica sfumatura di codifica è il BOM UTF-8 opzionale (Byte Order Mark): Excel su Windows tradizionalmente ha bisogno del BOM per rilevare correttamente UTF-8, altrimenti ricade sulla locale di sistema e mangia i caratteri non-ASCII. Attiva il BOM (o usa il preset Excel, che lo abilita di default) quando prevedi di aprire il CSV in Excel. Lascia il BOM disattivato per tutto il resto — la maggior parte dei parser moderni (PostgreSQL, Pandas, jq, Python csv) si bloccherà o includerà il BOM come carattere sparso all'inizio della prima cella.

Strumenti correlati

Vedi tutti gli strumenti →