Json To Csv LogoJson To Csv

Convert Large JSON to CSV Online Free : jusqu'où un navigateur peut-il vraiment aller ? (Guide 2026)

Les gros fichiers JSON se convertissent très bien dans un navigateur jusqu'à un certain point, et ce point est la mémoire, pas la vitesse. Ce guide mesure le vrai plafond avec le moteur de conversion de la page elle-même, montre la recette de découpage qui ne perd jamais une ligne, et dit honnêtement quand le travail revient à un script plutôt qu'à un onglet.

Mis à jour: 2026-10-2018 min de lecture

Ce que "gros" signifie vraiment pour un convertisseur dans le navigateur

Quand on dit qu'un fichier JSON est gros, cela peut signifier n'importe quoi entre cinq mille lignes et cinq gigaoctets, et ce sont des problèmes complètement différents. Un convertisseur dans le navigateur n'a pas un seul plafond. Il en a trois, et savoir lequel vous êtes sur le point d'atteindre vous dit s'il faut simplement convertir, découper, ou quitter complètement le navigateur.

Le premier plafond est l'analyse. Avant toute conversion, le navigateur transforme votre texte JSON en objets en mémoire avec JSON.parse, et les objets analysés occupent environ deux à trois fois la mémoire du texte dont ils proviennent. Un fichier de 25 Mo devient 50 à 75 Mo d'objets vivants avant qu'une seule cellule CSV existe. Le deuxième plafond est la saisie. Coller cinquante mégaoctets de texte dans une zone de texte est lent et désagréable sur n'importe quelle machine, et c'est pourquoi le bouton d'envoi existe : il confie le fichier au convertisseur sans le faire transiter par votre presse-papiers. Le troisième plafond est l'aperçu. Après la conversion, la page affiche un tableau pour que vous puissiez vérifier le résultat d'un coup d'œil, et afficher un demi-million de lignes de DOM est ce qui fige réellement les onglets. Remarquez ce qui manque dans cette liste : la vitesse de conversion. Comme le montrent les mesures ci-dessous, transformer les objets en texte CSV est l'étape la moins coûteuse de tout le pipeline.

Donc "puis-je convertir gratuitement en ligne un gros fichier JSON" pose en réalité trois questions plus petites. Le navigateur l'analysera-t-il sans manquer de mémoire. Le chemin de saisie le gérera-t-il correctement. L'aperçu survivra-t-il. Pour la plupart des fichiers que les gens appellent gros, la réponse aux trois est oui, et la suite de ce guide consiste à trouver la limite honnêtement plutôt que de la deviner.

Mesures : à quelle vitesse cette page convertit les gros fichiers

Chaque nombre de cette section a été mesuré sur la machine de compilation avec le moteur de conversion exact que cette page exécute dans votre navigateur, la même fonction jsonToCsv avec l'aplatissement activé, sur des données de commandes générées avec des objets clients imbriqués. La machine est un serveur ordinaire, pas une plateforme d'étalonnage optimisée, donc considérez ces valeurs comme le bon ordre de grandeur pour un ordinateur portable correct.

Mille lignes, 0,10 Mo de JSON : 20 millisecondes. Dix mille lignes, 1,01 Mo : 57 millisecondes. Cinquante mille lignes, 5,10 Mo : 221 millisecondes. Cent mille lignes, 10,21 Mo : 403 millisecondes. Deux cent cinquante mille lignes, 12,5 Mo : 636 millisecondes. Cinq cent mille lignes, 25,0 Mo : environ 1,4 seconde de temps moteur, 2,3 secondes de temps écoulé. Le CSV produit pour le fichier d'un demi-million de lignes pesait 11,7 Mo, et la ligne d'en-tête est sortie exactement comme prévu : id, item, qty, price, customer.name, customer.city.

Deux réserves honnêtes. Premièrement, ces temps ne concernent que la conversion. Votre navigateur analyse aussi le JSON d'abord et affiche ensuite le tableau d'aperçu, et l'aperçu est la partie coûteuse en haut de l'échelle. Un fichier qui se convertit en deux secondes peut quand même rendre l'onglet lourd pendant que l'affichage d'un demi-million de lignes de tableau se peint. Deuxièmement, les données de test générées sont uniformes. Les exports réels avec des clés irrégulières, une imbrication profonde ou des blocs de texte géants se convertissent un peu plus lentement, car le moteur parcourt chaque valeur. Même ainsi, la forme du résultat tient : l'étape de conversion reste sous la seconde bien au-delà de cent mille lignes, et reste dans les petites secondes simples à un demi-million. Si votre fichier se convertit lentement ailleurs, le convertisseur fait quelque chose de gaspilleux, car le travail lui-même est bon marché.

Temps de conversion mesurés (moteur de la page, machine de compilation)
rows        JSON size    convert time
1,000       0.10 MB      20 ms
10,000      1.01 MB      57 ms
50,000      5.10 MB      221 ms
100,000     10.21 MB     403 ms
250,000     12.5 MB      636 ms
500,000     25.0 MB      ~1.4 s engine / 2.3 s wall

# header produced for every file:
# id,item,qty,price,customer.name,customer.city

Le test de 60 secondes : essayez avant de compliquer

La plupart des angoisses autour des gros fichiers se règlent en essayant simplement. Utilisez le bouton d'envoi plutôt que le collage pour tout ce qui dépasse quelques mégaoctets, et surveillez le badge d'état au-dessus du convertisseur. Il passe de Prêt à Valide avec un nombre de lignes quand le JSON s'analyse proprement. Si l'onglet reste réactif et que le bouton de téléchargement vous remet un CSV, c'est fini, et aucune stratégie de découpage n'a jamais été nécessaire.

Deux détails rendent le test honnête. Premièrement, gardez la Conversion auto activée, ce qu'elle est par défaut : le CSV apparaît dès que le fichier se charge, donc vous voyez le résultat sans clic supplémentaire. Deuxièmement, faites confiance au nombre de lignes. Si le badge indique Valide avec 480 000 lignes et que vous en attendiez à peu près autant, l'analyse a compris votre fichier. Si le nombre est très éloigné, généralement 1, votre JSON est probablement un objet géant unique qui enveloppe le tableau, et le convertisseur a extrait ce qu'il a pu. C'est un problème de forme de fichier, pas de taille, et notre guide d'aplatissement explique le motif d'enveloppe.

Si l'onglet se fige, saccade longtemps, ou si le navigateur propose de tuer la page, arrêtez-vous et découpez. Ne rechargez pas la page en collant le même fichier en espérant un résultat différent. Le plafond de mémoire ne négocie pas, et la section suivante est le passage à travers.

Découper dans le navigateur : la recette qui ne perd jamais une ligne

Le découpage ressemble à un compromis, mais il est exact. Divisez le tableau JSON en morceaux, convertissez chaque morceau dans l'onglet, téléchargez un CSV par morceau, et réassemblez-les en gardant une seule ligne d'en-tête. Sur la machine de compilation, cela a été vérifié directement : un fichier de 20 000 lignes divisé en deux moitiés, chaque moitié convertie séparément, l'en-tête du second CSV retiré, les deux corps concaténés. Le résultat fusionné était identique octet par octet à la conversion du fichier entier d'un seul coup.

Pourquoi cela fonctionne mérite une phrase. Quand chaque morceau a la même forme, le convertisseur dérive la même liste de colonnes dans le même ordre pour chaque morceau, donc les corps s'alignent parfaitement et la seule chose à gérer est l'en-tête. Gardez l'en-tête du premier CSV, supprimez la ligne d'en-tête de chaque CSV suivant, et concaténez. Le seul cas qui demande de l'attention est celui des données irrégulières, où différentes lignes portent différentes clés : si le morceau un n'a jamais vu une colonne "notes" que le morceau deux possède, les colonnes ne s'aligneront pas. Pour les fichiers irréguliers, utilisez la voie du script dans la section ultérieure, qui calcule d'abord la liste complète des colonnes.

Combien de morceaux. Visez des morceaux que votre onglet convertit confortablement, ce que les mesures ci-dessus placent autour de 50 000 à 100 000 lignes chacun. Un fichier de 400 000 lignes devient quatre à huit morceaux, chacun se convertissant en moins d'une demi-seconde. Tout le travail, y compris vos clics, prend quelques minutes, et chaque ligne survit.

Diviser le fichier sans casser le JSON

L'erreur à éviter est de diviser le fichier comme du texte. Couper un fichier de 25 Mo en deux dans un éditeur de texte le casse presque toujours : un crochet laissé ouvert, une chaîne coupée au milieu d'un guillemet, une virgule orpheline à la limite. Divisez-le comme des données, avec un outil qui comprend le JSON, pour que chaque morceau reste un JSON valide à lui seul.

Le diviseur fiable le plus court est quelques lignes de Python. Chargez le fichier une fois, tranchez la liste, et écrivez chaque tranche dans son propre fichier. Vérifié sur la machine de compilation contre un fichier de 30 000 lignes : trois morceaux de 10 000 lignes, et le réassemblage des morceaux a reproduit le fichier original exactement. Si vous préférez rester au terminal, jq tranche les tableaux avec la même idée : jq '.[0:50000]' big.json > part1.json prend les cinquante mille premiers éléments, et jq '.[50000:100000]' prend les cinquante mille suivants. C'est la syntaxe de tranche standard de jq, documentée dans le manuel de jq.

Nommez les morceaux dans l'ordre, part1, part2, part3, et convertissez-les dans l'ordre. Les CSV sortent dans le même ordre, et l'étape de réassemblage est une simple concaténation avec la règle d'en-tête de la section précédente.

Diviser un tableau JSON en morceaux valides (vérifié)
import json

rows = json.load(open('big.json'))
chunk = 50000
for i in range(0, len(rows), chunk):
    part = rows[i:i+chunk]
    json.dump(part, open('part%d.json' % (i // chunk + 1), 'w'))
    print('part%d.json:' % (i // chunk + 1), len(part), 'rows')

# terminal alternative (standard jq slice syntax):
# jq '.[0:50000]' big.json > part1.json
# jq '.[50000:100000]' big.json > part2.json

Quand le fichier est trop gros pour n'importe quel onglet

Il existe un plafond honnête, et il vaut la peine de le nommer clairement. Si le navigateur ne peut pas du tout analyser le fichier en mémoire, aucun convertisseur en ligne ne peut aider, car chacun d'eux analyse d'abord. Les symptômes sont sans équivoque : l'onglet propose de tuer la page pendant le chargement, le navigateur signale une erreur de mémoire insuffisante, ou le fichier ne finit jamais d'être envoyé. À ce stade, le fichier a dépassé l'onglet, et le travail revient à un script exécuté sur votre machine, qui peut traiter les données sans jamais les contenir toutes sous forme d'objets à la fois.

Où se situe ce plafond en pratique. Cela dépend de la RAM de votre machine et du degré d'imbrication des données, mais les fichiers de centaines de mégaoctets de texte JSON sont là où les onglets commencent à mourir sur les ordinateurs portables ordinaires. Un fichier de 25 Mo s'est converti ici en environ deux secondes avec de la marge ; un fichier de 250 Mo est une autre bête, environ dix fois la pression mémoire, et un fichier de 1 Go relève fermement du territoire du script. Si vous ne savez pas de quel côté de la ligne vous êtes, le test de 60 secondes de la section précédente y répond empiriquement : un onglet mort est le fichier qui vous dit qu'il a besoin d'un script.

Une dernière note honnête. Certains sites annoncent une "taille de fichier illimitée" pour la conversion en ligne. Ce qu'ils veulent généralement dire, c'est que leurs serveurs acceptent l'envoi, ce qui déplace simplement le plafond de votre navigateur vers leur file d'attente, et confie vos données à un tiers au passage. Pour les fichiers assez gros pour compter, cet échange en vaut rarement la peine.

La voie du script : un Python par blocs qui survit aux données irrégulières

Quand le navigateur est hors jeu, voici le script. Il lit tout le fichier une fois, aplatit chaque bloc avec pandas, et écrit un CSV par bloc, et il gère le cas des données irrégulières que la recette du navigateur ne peut pas : les lignes avec des clés différentes. L'astuce est de calculer d'abord la liste complète des colonnes à partir de toutes les données, puis de forcer chaque bloc sur ces colonnes avant d'écrire. Vérifié sur la machine de compilation contre un fichier de 30 000 lignes où certaines lignes portaient un champ notes et d'autres un champ flag : trois CSV de blocs fusionnés en une sortie identique octet par octet à la conversion du fichier d'un seul coup, en 0,4 seconde.

Le motif monte en charge plus loin que le navigateur ne le pourrait jamais. Comme chaque bloc est converti et écrit avant le chargement du suivant, le pic de mémoire reste proportionnel à la taille du bloc, pas à la taille du fichier. Augmentez la taille du bloc pour la vitesse sur une grosse machine, diminuez-la si la mémoire est serrée. Et la même astuce d'union des colonnes vous protège chaque fois que les exports changent de forme à mi-chemin, ce que les exports réels adorent faire.

Il reste un jugement à porter : un CSV par bloc contre un seul fichier fusionné. Le script ci-dessous écrit un fichier par bloc, ce qui garde chaque morceau utilisable indépendamment. Si vous voulez un seul fichier, concaténez-les avec la même règle d'en-tête que la recette du navigateur : gardez l'en-tête du premier fichier, supprimez les autres.

Conversion par blocs sûre pour les données irrégulières (vérifiée, pandas)
import json, pandas as pd

rows = json.load(open('big.json'))
cols = list(pd.json_normalize(rows).columns)  # union of all keys

chunk = 50000
for i in range(0, len(rows), chunk):
    part = pd.json_normalize(rows[i:i+chunk]).reindex(columns=cols)
    part.to_csv('out_part%d.csv' % (i // chunk + 1), index=False)

# merge the parts into one CSV (keep one header):
# head -n 1 out_part1.csv > merged.csv
# tail -n +2 -q out_part*.csv >> merged.csv

Gros fichiers et confidentialité : pourquoi le côté client compte encore plus à grande échelle

Les gros fichiers sont généralement des fichiers sensibles. Un export de 500 000 lignes est rarement un jeu de données jouet ; ce sont des clients, des commandes, des journaux, ou des dossiers patients. C'est exactement à ce moment-là que l'architecture du convertisseur compte le plus, et c'est l'avantage discret de faire cela dans un onglet de navigateur plutôt que sur le serveur de quelqu'un.

Le convertisseur de cette page s'exécute entièrement dans votre navigateur après le chargement de la page. Cela a été vérifié contre le code source de la page elle-même pour notre guide de téléchargement : le moteur de conversion est importé comme code local côté client, et la seule requête réseau de tout le convertisseur est le bouton optionnel d'import depuis une URL, qui ne s'exécute que quand vous cliquez dessus et ne récupère que l'adresse que vous tapez. Vos données collées ou envoyées ne sont jamais transmises nulle part, ce qui signifie qu'aucun tiers ne voit jamais le fichier, aucune file d'envoi à attendre, et aucune politique de conservation à lire.

C'est aussi pourquoi la recette de découpage ci-dessus est sûre pour les données privées. Chaque morceau se convertit sur votre machine, et les morceaux ne la quittent jamais. Si votre fichier est assez gros pour exiger la voie du script, la même propriété tient : le script Python s'exécute localement, et rien en lui ne touche le réseau.

Ce qu'il ne faut pas faire avec un gros fichier

Quatre erreurs reviennent constamment. Premièrement, coller des dizaines de mégaoctets dans la zone de saisie au lieu d'utiliser le bouton d'envoi. Le chemin d'envoi existe précisément pour cela, et le collage est la façon la plus lente de faire entrer un gros fichier dans n'importe quelle page. Deuxièmement, minifier le JSON en espérant qu'il rétrécisse assez pour compter. La minification économise peut-être dix pour cent sur les exports typiques, ce qui transforme un fichier trop gros en un fichier encore trop gros. Troisièmement, ouvrir un CSV de 500 000 lignes dans un tableur pour "le vérifier". Les tableurs plafonnent autour d'un million de lignes et s'affichent lentement bien avant ; vérifiez le nombre de lignes et contrôlez le début et la fin du fichier à la place. Quatrièmement, convertir à la main chaque semaine le même export géant. Si le fichier arrive selon un calendrier, le script Python de la section précédente est une installation unique qui bat cinquante conversions manuelles.

Et une chose à ne pas craindre : l'aplatissement. Les données imbriquées ne changent pas significativement le calcul de taille. Le bascule d'aplatissement transforme les objets imbriqués en colonnes en notation pointée, ce que le moteur fait dans le même passage que tout le reste, et les mesures ci-dessus ont toutes été prises avec l'aplatissement activé.

Guides associés

Questions fréquentes

Existe-t-il un outil en ligne gratuit pour convertir un gros fichier JSON en CSV ?

Oui, le convertisseur de cette page est gratuit sans inscription et sans limite de taille de notre côté. Envoyez le fichier, regardez le badge d'état confirmer le nombre de lignes, et téléchargez le CSV. Vos données ne quittent jamais votre machine car la conversion s'exécute entièrement dans votre navigateur. Pour les fichiers au-delà de quelques centaines de milliers de lignes, divisez d'abord le fichier en morceaux avec la recette de ce guide.

Quelle taille maximale de fichier JSON puis-je convertir en ligne ?

Il n'y a pas de limite stricte sur cette page ; le plafond pratique est la mémoire de l'onglet de votre navigateur. Mesuré avec le moteur propre de la page, 25 Mo / 500 000 lignes se convertissent en environ deux secondes, avec de la marge. Au-delà, la mémoire de l'onglet pour l'analyse et le tableau d'aperçu devient la limite, pas la conversion. Si l'onglet se fige ou meurt, découpez le fichier ou passez à la voie du script dans ce guide.

Comment diviser un gros fichier JSON en fichiers plus petits ?

Divisez-le comme des données, pas comme du texte, pour que chaque morceau reste un JSON valide. En Python : json.load le fichier, tranchez la liste en morceaux, json.dump chaque morceau. Au terminal : jq '.[0:50000]' big.json > part1.json prend les cinquante mille premiers éléments. Ne coupez jamais le fichier dans un éditeur de texte, ce qui casse les crochets et les guillemets à la limite.

Découper en morceaux modifie-t-il mon fichier CSV ?

Non, tant que chaque morceau a la même forme. Vérifié sur la machine de compilation : un fichier divisé en deux, converti en deux morceaux, et réassemblé en gardant un seul en-tête a produit une sortie identique octet par octet à la conversion du fichier entier d'un seul coup. L'exception est les données irrégulières où les lignes portent des clés différentes ; pour cela, utilisez le script de ce guide, qui calcule la liste complète des colonnes avant d'écrire le moindre morceau.

Est-il sans risque de convertir en ligne un gros fichier JSON avec des données sensibles ?

Sur cette page, oui. La conversion s'exécute entièrement dans votre navigateur : le moteur est du code local côté client et votre fichier n'est jamais envoyé à aucun serveur. La seule requête réseau du convertisseur est le bouton optionnel d'import depuis une URL. Cela rend la voie du navigateur, et la recette de découpage, sûres pour les exports privés que vous ne confieriez pas à un service tiers.

Pourquoi mon navigateur se fige quand je convertis un gros fichier JSON ?

Habituellement le tableau d'aperçu, pas la conversion. Afficher des centaines de milliers de lignes de tableau est bien plus coûteux que de produire le texte CSV. Coller un fichier énorme dans la zone de saisie au lieu de l'envoyer aggrave les choses. Envoyez le fichier, et si l'onglet peine encore, convertissez par morceaux : chaque morceau reste assez petit pour que l'aperçu s'affiche instantanément.

Puis-je convertir un fichier JSON de 1 Go en CSV dans un navigateur ?

Honnêtement, non. Un fichier de cette taille dépasse ce qu'un onglet de navigateur peut analyser en mémoire, et aucun convertisseur en ligne ne change cela. Utilisez un script sur votre machine : Python avec json_normalize par blocs comme montré dans ce guide, ou un outil de streaming pour les données JSON-lines. Si le fichier est un tableau géant unique, envisagez de le convertir d'abord en JSON-lines, un objet par ligne, qui se traite proprement en flux.

Testez-le maintenant sur votre gros fichier

Collez un morceau de votre gros JSON et regardez le convertisseur le traiter en millisecondes. Gratuit, sans inscription, fonctionne entièrement dans votre navigateur.

Ouvrir le convertisseur JSON en CSV
Tous les guides