Découper un fichier JSONL

Découpez vos fichiers JSONL (JSON Lines) volumineux en fichiers plus petits, selon le nombre de lignes ou la taille souhaitée. Le traitement se fait à 100% dans votre navigateur : vos données ne le quittent jamais.

JSONL à découper

Déposez un fichier .jsonl ici ou cliquez pour en sélectionner un

Formats acceptés : .jsonl, .ndjson, .json, .txt

Options de découpage

Résultat du découpage

Collez du contenu JSONL ou déposez un fichier, réglez les options, puis lancez le découpage

Comment découper un fichier JSONL

Importez votre fichier JSONL volumineux ou collez son contenu dans la zone de saisie. L’outil accepte les fichiers .jsonl, .ndjson, .json et .txt de toute taille.

Choisissez un découpage par nombre de lignes (par exemple, 1000 lignes par fichier) ou par taille (par exemple, 10 Mo par fichier). L’outil traite chaque ligne séparément et préserve l’intégrité de chaque enregistrement JSON.

Une fois le découpage terminé, téléchargez chaque partie séparément ou cliquez sur « Tout télécharger en ZIP » pour toutes les récupérer dans une seule archive. Chaque fichier obtenu est un fichier JSONL valide, prêt à l’emploi.

Découper par lignes ou par taille : pourquoi ne pas simplement utiliser split -b ?

L’intérêt d’un outil de découpage JSONL tient à une garantie : aucun enregistrement n’est jamais coupé en deux. Un découpage générique par octets ne peut pas le garantir. Voici les trois méthodes comparées :

MéthodeGarantieQuand l’utiliser
Par nombre de lignes (cet outil)Chaque bloc contient exactement N enregistrements completsPour les systèmes qui facturent ou imposent une limite par enregistrement : lots de requêtes API, échantillons de test
Par taille cible, en respectant les lignes (cet outil)Blocs proches de la taille limite, découpés uniquement aux sauts de ligneQuand la taille des fichiers envoyés est limitée en mégaoctets : chaque partie reste un fichier JSONL valide
Découpage brut par octets — split -b 100MAucune : un enregistrement est presque toujours coupé au niveau d’un octetJamais pour du JSONL : chaque bloc, sauf le premier, commence généralement par un fragment d’enregistrement

Choisir la taille des blocs pour l’API Batch d’OpenAI

Le cas typique de découpage en 2026 : l’API Batch d’OpenAI limite chaque fichier d’entrée à 50,000 requêtes et 200 MB. Ces deux limites doivent être respectées simultanément. Calculez donc la taille des blocs à partir de vos propres données :

# Mesurer le fichier
wc -l batch_input.jsonl        # → e.g. 120,000 requests
du -m batch_input.jsonl        # → e.g. 310 MB


# Lignes par bloc = floor(min(50000, 120000 × 200/310))
#                  = floor(min(50000, 77419)) = 50000 → mais vérifier la taille :
# 50000 lignes ≈ 129 MB ✓ sous la limite de 200 MB — fractionner par blocs de 50,000 lignes
split -l 50000 batch_input.jsonl part_


# Résultat : part_aa, part_ab, part_ac — 3 fichiers de traitement par lots valides

Le même calcul s’applique à toute destination qui impose deux limites (lignes ET mégaoctets). Dans cet outil, qui fonctionne dans le navigateur, indiquez le nombre de lignes par bloc : la taille de chaque fichier obtenu s’affiche avant le téléchargement, sans calcul à faire.

Qu’est-ce que le découpage JSONL ?

Le découpage JSONL consiste à répartir les enregistrements d’un fichier JSONL (JSON Lines) volumineux dans plusieurs fichiers plus petits. Chaque ligne étant un objet JSON indépendant, le découpage est simple et ne coupe jamais un enregistrement en deux.

Cette opération est essentielle si vous utilisez des plateformes de machine learning qui limitent la taille des fichiers importés, des API de traitement par lots qui imposent un nombre maximal d’enregistrements par requête, ou des pipelines de données plus performants avec de petits fichiers en entrée. Le découpage permet de traiter les données par blocs faciles à gérer, sans en modifier le contenu.

Cas d’usage courants

Limites de l’API Batch d’OpenAI
Découpez vos fichiers JSONL volumineux pour respecter les limites de l’API Batch d’OpenAI (100 Mo par fichier, 50 000 requêtes par lot).
Partitionnement des données d’entraînement en machine learning
Répartissez vos jeux de données d’entraînement volumineux en ensembles d’entraînement, de validation et de test, ou en blocs de même taille pour l’entraînement distribué.
Traitement parallèle
Découpez vos fichiers JSONL en blocs pour les traiter en parallèle sur plusieurs workers, threads ou fonctions serverless.
Limites de taille à l’import
Découpez vos exports JSONL volumineux en fichiers plus petits pour respecter les limites d’envoi des plateformes (AWS S3 multipart, GitHub, pièces jointes d’e-mail).
Chargement incrémental des données
Découpez vos jeux de données volumineux en petits lots pour les charger progressivement dans des bases de données ou des entrepôts de données et éviter les timeouts.
Gestion des versions avec Git
Découpez vos très gros fichiers de données JSONL en fichiers plus petits pour les versionner avec Git, éviter les avertissements liés aux fichiers volumineux et rendre les diffs plus lisibles.

Problèmes courants et solutions

Le découpage produit des fichiers vides

Cela peut arriver si le nombre de lignes par fichier dépasse le nombre total de lignes. Réduisez ce nombre ou choisissez un découpage par taille.

Le découpage par taille produit des fichiers de tailles différentes

Avec le découpage par taille, la dernière partie peut être plus petite que la taille cible, car les lignes ne sont jamais coupées au milieu d’un enregistrement. Chaque fichier ne contient que des lignes JSON complètes.

Le navigateur ralentit avec les très gros fichiers

Pour les fichiers de plus de 500 Mo, le navigateur peut ralentir pendant le traitement. Pour les jeux de données extrêmement volumineux, envisagez un découpage en ligne de commande avec des outils comme 'split' ou 'wc -l', puis utilisez cet outil pour vérifier le résultat.

Questions fréquentes

Mes données sont-elles en sécurité pendant le découpage ?

Oui. Le découpage se fait entièrement en local, dans votre navigateur, en JavaScript. Aucune donnée n’est envoyée à un serveur. Votre contenu JSONL ne quitte jamais votre appareil.

Y a-t-il une limite de taille pour les fichiers ?

Il n’y a pas de limite stricte. L’outil peut traiter des fichiers de plusieurs centaines de mégaoctets. Les performances dépendent de votre navigateur et de la mémoire de votre appareil.

Le découpage conserve-t-il l’ordre des enregistrements ?

Oui. Les enregistrements sont répartis dans l’ordre : le premier fichier contient les N premières lignes, le deuxième les N suivantes, et ainsi de suite. Aucun enregistrement n’est déplacé ni dupliqué.

Puis-je découper un fichier en fonction du nombre de lignes et de la taille des fichiers à la fois ?

Vous ne pouvez choisir qu’un seul mode de découpage à la fois. Si vous devez respecter les deux contraintes, commencez par découper selon la plus restrictive, puis vérifiez que les fichiers obtenus respectent les deux limites.

Que deviennent les lignes vides du fichier JSONL ?

Les lignes vides sont conservées lors du découpage. Si votre fichier JSONL en contient entre les enregistrements, elles resteront à leur place dans les fichiers obtenus. Si nécessaire, utilisez notre validateur JSONL pour supprimer les lignes vides avant le découpage.

Puis-je fusionner les fichiers obtenus pour reconstituer le fichier d’origine ?

Oui. Chaque fichier obtenu étant un fichier JSONL valide, vous pouvez les concaténer pour reconstituer le fichier d’origine. En ligne de commande, utilisez 'cat part_*.jsonl > merged.jsonl'. Vous pouvez aussi utiliser nos outils JSONL pour réunir les fichiers.

Comment les fichiers issus du découpage sont-ils nommés ?

Les fichiers obtenus portent un numéro de partie séquentiel (par exemple, part_001.jsonl, part_002.jsonl). Si vous choisissez le téléchargement en ZIP, toutes les parties sont regroupées dans une seule archive.

Comment fonctionne le découpage des fichiers selon leur taille ?

Le découpage par taille ajoute des lignes au fichier courant jusqu’à atteindre la taille cible. Ce fichier est alors fermé et un nouveau commence à la ligne suivante. Une ligne n’est jamais répartie sur plusieurs fichiers : chaque partie peut donc être légèrement plus grande ou plus petite que la taille cible.

Outils et guides associés