JSON vers Interface TypeScript

JSON vers Interface TypeScript

Convertissez instantanément n'importe quel objet JSON en interfaces TypeScript propres. Outil gratuit en ligne — supporte les objets imbriqués, tableaux et...

Mis à jour avril 2026

Vérifié par Rafael Duarte

Root Interface Name
Output
1
TypeScript Interface

// Paste JSON on the left // to generate TypeScript interfaces

Shift + Enter pour Copier

Convertisseur JSON vers interface TypeScript

D'un JSON brut à une interface prête pour la production

1. Collez votre JSON

Une réponse d'API, un fichier de config ou un enregistrement de base de données — tout objet ou tableau valide fonctionne.

2. Nommez l'interface racine

Par défaut `RootObject` — renommez-la selon votre domaine, comme `Utilisateur` ou `Commande`.

3. Copiez le résultat

Cliquez sur Copy ou appuyez sur `Shift+Enter`, puis collez directement dans vos fichiers `.ts`/`.tsx`.

Ce que fait cet outil

Couvre toute la variété de JSON rencontrée en conditions réelles

Objets imbriqués

Chaque objet interne reçoit sa propre interface nommée, ordonnées pour que les dépendances apparaissent avant d'être utilisées.

Tableaux typés

Les primitifs deviennent string[]/number[] ; les tableaux d'objets génèrent une interface dédiée + [].

Bascule interface / type

Passez de interface à type selon la convention en vigueur dans votre projet.

Champs nuls

Les valeurs null sont typées correctement, prêtes à être étendues en union type si besoin.

Réparation automatique du JSON cassé

Le bouton Fix utilise la librairie jsonrepair pour corriger une virgule en trop, des guillemets manquants ou des accolades non fermées avant de générer les interfaces.

Accepte un tableau d'objets à la racine

Collez un tableau — comme une liste d'utilisateurs renvoyée par une API — et l'outil génère l'interface à partir du premier élément, sans extraction manuelle.

Comment chaque type JSON devient du TypeScript

JSON
TypeScript
string
string
42
number
true
boolean
["a", "b"]
string[]
{"profil": {...}}
profil: Profil (+ interface Profil séparée)

Quand vous allez utiliser cet outil

Les scénarios les plus courants chez les personnes qui l'utilisent

Typer les réponses d'une API REST

Collez le JSON renvoyé par le backend et obtenez des interfaces prêtes pour fetch ou axios.

Typer des fichiers de configuration

Convertissez un config.json en interface pour l'autocomplétion des clés dans l'éditeur.

Accélérer le développement

Éliminez le code répétitif consistant à écrire des interfaces à la main pour des payloads complexes.

Intégrer des API tierces

Collez une réponse d'exemple pour comprendre le format et générer des types de départ.

Prototyper rapidement avant de coder

Générez la structure typée en quelques secondes pour avoir l'autocomplétion dans l'éditeur avant même d'écrire la logique métier de la fonctionnalité.

Relire le résultat avec coloration syntaxique

Le panneau de sortie colore séparément mots-clés, types primitifs, noms d'interface et champs, ce qui facilite la relecture visuelle d'une grosse interface avant de la coller dans l'éditeur.

Erreurs courantes

Attendre des types optionnels automatiques

Le générateur type à partir des données fournies — les champs qui peuvent manquer nécessitent un ? ajouté manuellement ensuite.

Traiter `null` comme un type final

En production, étendez plutôt vers string | null selon ce que le champ peut réellement recevoir.

Tableaux vides sans contexte

Ils donnent unknown[] — le type des éléments ne peut pas être déduit sans données d'exemple.

Nom d'interface racine avec espaces ou symboles

À la différence des interfaces imbriquées (converties automatiquement en PascalCase), le nom de l'interface racine est utilisé tel que saisi — des espaces ou caractères invalides produisent du TypeScript qui ne compile pas.

Coller un tableau de primitifs à la racine

La racine doit être un objet ou un tableau d'objets. Un tableau de simples chaînes ou nombres n'a aucun champ à typer et ne renvoie qu'un commentaire d'avertissement, sans interface.

Attendre un tuple plutôt qu'une union pour les tableaux mixtes

Un tableau comme ["a", 1, true] ne devient pas un tuple positionnel — le générateur crée une union (string | number | boolean)[], car TypeScript ne peut pas déduire de positions fixes à partir de JSON libre.

Pourquoi utiliser cet outil

Traite les structures imbriquées de façon récursive, une interface par niveau, ordonnées pour que les dépendances apparaissent avant d'être utilisées — sans avoir à organiser cela à la main.

Compatible avec TypeScript 3.0+ et tout framework moderne — React, Next.js, Vue, Angular ou Node.js.

Fonctionne à 100 % dans le navigateur : rien du JSON collé n'est envoyé à un serveur externe, ce qui permet de typer en toute sécurité des payloads réels contenant des données sensibles.

`interface` vs. `type`

Les deux disponibles via le bouton bascule de l'outil

interface
type
Supporte `extends`
oui
via intersection (`&`)
Declaration merging
oui
non
Idéal pour
API publiques, bibliothèques
unions et intersections complexes

Questions fréquentes

Collez le JSON — le générateur traite les objets imbriqués de façon récursive, chacun recevant sa propre interface nommée, ordonnées pour que les dépendances apparaissent en premier.

Ressources

Article associé

DTO, entity e value object: qual é a diferença e quando usar cada um

Outils connexes